@aws-cdk/aws-amplify-alpha

AWS Amplify Construct Library

Version 2.274.0-alpha.0

Separate package

@aws-cdk/aws-amplify-alpha is not part of aws-cdk-lib — install it separately:

npm install @aws-cdk/aws-amplify-alpha
pip install aws-cdk.aws-amplify-alpha

This module is experimental (alpha): its API may change in any release, without a major version bump.

---

The APIs of higher level constructs in this module are experimental and under active development. They are subject to non-backward compatible changes or removal in any future version. These are not subject to the Semantic Versioning model and breaking changes will be announced in the release notes. This means that while you may use them, you may need to update your source code when upgrading to a newer version of this package.

---

The AWS Amplify Console provides a Git-based workflow for deploying and hosting fullstack serverless web applications. A fullstack serverless app consists of a backend built with cloud resources such as GraphQL or REST APIs, file and data storage, and a frontend built with single page application frameworks such as React, Angular, Vue, or Gatsby.

Setting up an app with branches, custom rules and a domain

To set up an Amplify Console app, define an App:

import * as codebuild from 'aws-cdk-lib/aws-codebuild';

const amplifyApp = new amplify.App(this, 'MyApp', {
  sourceCodeProvider: new amplify.GitHubSourceCodeProvider({
    owner: '<user>',
    repository: '<repo>',
    oauthToken: SecretValue.secretsManager('my-github-token'),
  }),
  buildSpec: codebuild.BuildSpec.fromObjectToYaml({
    // Alternatively add a `amplify.yml` to the repo
    version: '1.0',
    frontend: {
      phases: {
        preBuild: {
          commands: [
            'yarn',
          ],
        },
        build: {
          commands: [
            'yarn build',
          ],
        },
      },
      artifacts: {
        baseDirectory: 'public',
        files:
        - '**/*',
      },
    },
  }),
});

import aws_cdk.aws_codebuild as codebuild


amplify_app = amplify.App(self, "MyApp",
    source_code_provider=amplify.GitHubSourceCodeProvider(
        owner="<user>",
        repository="<repo>",
        oauth_token=SecretValue.secrets_manager("my-github-token")
    ),
    build_spec=codebuild.BuildSpec.from_object_to_yaml({
        # Alternatively add a `amplify.yml` to the repo
        "version": "1.0",
        "frontend": {
            "phases": {
                "pre_build": {
                    "commands": ["yarn"
                    ]
                },
                "build": {
                    "commands": ["yarn build"
                    ]
                }
            },
            "artifacts": {
                "base_directory": "public",
                "files": -"**/*"
            }
        }
    })
)

import software.amazon.awscdk.services.codebuild.*;


App amplifyApp = App.Builder.create(this, "MyApp")
        .sourceCodeProvider(GitHubSourceCodeProvider.Builder.create()
                .owner("<user>")
                .repository("<repo>")
                .oauthToken(SecretValue.secretsManager("my-github-token"))
                .build())
        .buildSpec(BuildSpec.fromObjectToYaml(Map.of(
                // Alternatively add a `amplify.yml` to the repo
                "version", "1.0",
                "frontend", Map.of(
                        "phases", Map.of(
                                "preBuild", Map.of(
                                        "commands", List.of("yarn")),
                                "build", Map.of(
                                        "commands", List.of("yarn build"))),
                        "artifacts", Map.of(
                                "baseDirectory", "public",
                                "files", -"**/*")))))
        .build();

using Amazon.CDK.AWS.CodeBuild;


var amplifyApp = new App(this, "MyApp", new AppProps {
    SourceCodeProvider = new GitHubSourceCodeProvider(new GitHubSourceCodeProviderProps {
        Owner = "<user>",
        Repository = "<repo>",
        OauthToken = SecretValue.SecretsManager("my-github-token")
    }),
    BuildSpec = BuildSpec.FromObjectToYaml(new Dictionary<string, object> {
        // Alternatively add a `amplify.yml` to the repo
        { "version", "1.0" },
        { "frontend", new Dictionary<string, IDictionary<string, IDictionary<string, string[]>>> {
            { "phases", new Struct {
                PreBuild = new Struct {
                    Commands = new [] { "yarn" }
                },
                Build = new Struct {
                    Commands = new [] { "yarn build" }
                }
            } },
            { "artifacts", new Struct {
                BaseDirectory = "public",
                Files = -"**/*"
            } }
        } }
    })
});

import codebuild "github.com/aws/aws-cdk-go/awscdk"


amplifyApp := amplify.NewApp(this, jsii.String("MyApp"), &AppProps{
	SourceCodeProvider: amplify.NewGitHubSourceCodeProvider(&GitHubSourceCodeProviderProps{
		Owner: jsii.String("<user>"),
		Repository: jsii.String("<repo>"),
		OauthToken: awscdk.SecretValue_SecretsManager(jsii.String("my-github-token")),
	}),
	BuildSpec: codebuild.BuildSpec_FromObjectToYaml(map[string]interface{}{
		// Alternatively add a `amplify.yml` to the repo
		"version": jsii.String("1.0"),
		"frontend": map[string]map[string]map[string][]*string{
			"phases": map[string]map[string][]*string{
				"preBuild": map[string][]*string{
					"commands": []*string{
						jsii.String("yarn"),
					},
				},
				"build": map[string][]*string{
					"commands": []*string{
						jsii.String("yarn build"),
					},
				},
			},
			"artifacts": map[string]interface{}{
				"baseDirectory": jsii.String("public"),
				"files": -jsii.String("**/*"),
			},
		},
	}),
})

To connect your App to GitLab, use the GitLabSourceCodeProvider:

const amplifyApp = new amplify.App(this, 'MyApp', {
  sourceCodeProvider: new amplify.GitLabSourceCodeProvider({
    owner: '<user>',
    repository: '<repo>',
    oauthToken: SecretValue.secretsManager('my-gitlab-token'),
  }),
});

amplify_app = amplify.App(self, "MyApp",
    source_code_provider=amplify.GitLabSourceCodeProvider(
        owner="<user>",
        repository="<repo>",
        oauth_token=SecretValue.secrets_manager("my-gitlab-token")
    )
)

App amplifyApp = App.Builder.create(this, "MyApp")
        .sourceCodeProvider(GitLabSourceCodeProvider.Builder.create()
                .owner("<user>")
                .repository("<repo>")
                .oauthToken(SecretValue.secretsManager("my-gitlab-token"))
                .build())
        .build();

var amplifyApp = new App(this, "MyApp", new AppProps {
    SourceCodeProvider = new GitLabSourceCodeProvider(new GitLabSourceCodeProviderProps {
        Owner = "<user>",
        Repository = "<repo>",
        OauthToken = SecretValue.SecretsManager("my-gitlab-token")
    })
});

amplifyApp := amplify.NewApp(this, jsii.String("MyApp"), &AppProps{
	SourceCodeProvider: amplify.NewGitLabSourceCodeProvider(&GitLabSourceCodeProviderProps{
		Owner: jsii.String("<user>"),
		Repository: jsii.String("<repo>"),
		OauthToken: awscdk.SecretValue_SecretsManager(jsii.String("my-gitlab-token")),
	}),
})

To connect your App to CodeCommit, use the CodeCommitSourceCodeProvider:

import * as codecommit from 'aws-cdk-lib/aws-codecommit';

const repository = new codecommit.Repository(this, 'Repo', {
  repositoryName: 'my-repo',
});

const amplifyApp = new amplify.App(this, 'App', {
  sourceCodeProvider: new amplify.CodeCommitSourceCodeProvider({ repository }),
});

import aws_cdk.aws_codecommit as codecommit


repository = codecommit.Repository(self, "Repo",
    repository_name="my-repo"
)

amplify_app = amplify.App(self, "App",
    source_code_provider=amplify.CodeCommitSourceCodeProvider(repository=repository)
)

import software.amazon.awscdk.services.codecommit.*;


Repository repository = Repository.Builder.create(this, "Repo")
        .repositoryName("my-repo")
        .build();

App amplifyApp = App.Builder.create(this, "App")
        .sourceCodeProvider(CodeCommitSourceCodeProvider.Builder.create().repository(repository).build())
        .build();

using Amazon.CDK.AWS.CodeCommit;


var repository = new Repository(this, "Repo", new RepositoryProps {
    RepositoryName = "my-repo"
});

var amplifyApp = new App(this, "App", new AppProps {
    SourceCodeProvider = new CodeCommitSourceCodeProvider(new CodeCommitSourceCodeProviderProps { Repository = repository })
});

import codecommit "github.com/aws/aws-cdk-go/awscdk"


repository := codecommit.NewRepository(this, jsii.String("Repo"), &RepositoryProps{
	RepositoryName: jsii.String("my-repo"),
})

amplifyApp := amplify.NewApp(this, jsii.String("App"), &AppProps{
	SourceCodeProvider: amplify.NewCodeCommitSourceCodeProvider(&CodeCommitSourceCodeProviderProps{
		Repository: *Repository,
	}),
})

The IAM role associated with the App will automatically be granted the permission to pull the CodeCommit repository.

Add branches:

declare const amplifyApp: amplify.App;

const main = amplifyApp.addBranch('main'); // `id` will be used as repo branch name
const dev = amplifyApp.addBranch('dev', {
  performanceMode: true, // optional, enables performance mode
});
dev.addEnvironment('STAGE', 'dev');

# amplify_app: amplify.App


main = amplify_app.add_branch("main") # `id` will be used as repo branch name
dev = amplify_app.add_branch("dev",
    performance_mode=True
)
dev.add_environment("STAGE", "dev")

App amplifyApp;


Branch main = amplifyApp.addBranch("main"); // `id` will be used as repo branch name
Branch dev = amplifyApp.addBranch("dev", BranchOptions.builder()
        .performanceMode(true)
        .build());
dev.addEnvironment("STAGE", "dev");

App amplifyApp;


var main = amplifyApp.AddBranch("main"); // `id` will be used as repo branch name
var dev = amplifyApp.AddBranch("dev", new BranchOptions {
    PerformanceMode = true
});
dev.AddEnvironment("STAGE", "dev");

var amplifyApp App


main := amplifyApp.AddBranch(jsii.String("main")) // `id` will be used as repo branch name
dev := amplifyApp.AddBranch(jsii.String("dev"), &BranchOptions{
	PerformanceMode: jsii.Boolean(true),
})
dev.AddEnvironment(jsii.String("STAGE"), jsii.String("dev"))

Auto build and pull request preview are enabled by default.

Add custom rules for redirection:

import { CustomRule } from '@aws-cdk/aws-amplify-alpha';

declare const amplifyApp: amplify.App;
amplifyApp.addCustomRule(new CustomRule({
  source: '/docs/specific-filename.html',
  target: '/documents/different-filename.html',
  status: amplify.RedirectStatus.TEMPORARY_REDIRECT,
}));

from aws_cdk.aws_amplify_alpha import CustomRule

# amplify_app: amplify.App

amplify_app.add_custom_rule(CustomRule(
    source="/docs/specific-filename.html",
    target="/documents/different-filename.html",
    status=amplify.RedirectStatus.TEMPORARY_REDIRECT
))

import software.amazon.awscdk.services.amplify.alpha.CustomRule;

App amplifyApp;

amplifyApp.addCustomRule(CustomRule.Builder.create()
        .source("/docs/specific-filename.html")
        .target("/documents/different-filename.html")
        .status(RedirectStatus.TEMPORARY_REDIRECT)
        .build());

using Amazon.CDK.AWS.Amplify.Alpha;

App amplifyApp;

amplifyApp.AddCustomRule(new CustomRule(new CustomRuleOptions {
    Source = "/docs/specific-filename.html",
    Target = "/documents/different-filename.html",
    Status = RedirectStatus.TEMPORARY_REDIRECT
}));

import "github.com/aws/aws-cdk-go/awscdkamplifyalpha"

var amplifyApp App

amplifyApp.AddCustomRule(awscdkamplifyalpha.NewCustomRule(&CustomRuleOptions{
	Source: jsii.String("/docs/specific-filename.html"),
	Target: jsii.String("/documents/different-filename.html"),
	Status: amplify.RedirectStatus_TEMPORARY_REDIRECT,
}))

When working with a single page application (SPA), use the CustomRule.SINGLE_PAGE_APPLICATION_REDIRECT to set up a 200 rewrite for all files to index.html except for the following file extensions: css, gif, ico, jpg, js, png, txt, svg, woff, ttf, map, json, webmanifest.

declare const mySinglePageApp: amplify.App;

mySinglePageApp.addCustomRule(amplify.CustomRule.SINGLE_PAGE_APPLICATION_REDIRECT);

# my_single_page_app: amplify.App


my_single_page_app.add_custom_rule(amplify.CustomRule.SINGLE_PAGE_APPLICATION_REDIRECT)

App mySinglePageApp;


mySinglePageApp.addCustomRule(CustomRule.SINGLE_PAGE_APPLICATION_REDIRECT);

App mySinglePageApp;


mySinglePageApp.AddCustomRule(CustomRule.SINGLE_PAGE_APPLICATION_REDIRECT);

var mySinglePageApp App


mySinglePageApp.AddCustomRule(amplify.CustomRule_SINGLE_PAGE_APPLICATION_REDIRECT())

Add a domain and map sub domains to branches:

declare const amplifyApp: amplify.App;
declare const main: amplify.Branch;
declare const dev: amplify.Branch;

const domain = amplifyApp.addDomain('example.com', {
  enableAutoSubdomain: true, // in case subdomains should be auto registered for branches
  autoSubdomainCreationPatterns: ['*', 'pr*'], // regex for branches that should auto register subdomains
});
domain.mapRoot(main); // map main branch to domain root
domain.mapSubDomain(main, 'www');
domain.mapSubDomain(dev); // sub domain prefix defaults to branch name

# amplify_app: amplify.App
# main: amplify.Branch
# dev: amplify.Branch


domain = amplify_app.add_domain("example.com",
    enable_auto_subdomain=True,  # in case subdomains should be auto registered for branches
    auto_subdomain_creation_patterns=["*", "pr*"]
)
domain.map_root(main) # map main branch to domain root
domain.map_sub_domain(main, "www")
domain.map_sub_domain(dev)

App amplifyApp;
Branch main;
Branch dev;


Domain domain = amplifyApp.addDomain("example.com", DomainOptions.builder()
        .enableAutoSubdomain(true) // in case subdomains should be auto registered for branches
        .autoSubdomainCreationPatterns(List.of("*", "pr*"))
        .build());
domain.mapRoot(main); // map main branch to domain root
domain.mapSubDomain(main, "www");
domain.mapSubDomain(dev);

App amplifyApp;
Branch main;
Branch dev;


var domain = amplifyApp.AddDomain("example.com", new DomainOptions {
    EnableAutoSubdomain = true,  // in case subdomains should be auto registered for branches
    AutoSubdomainCreationPatterns = new [] { "*", "pr*" }
});
domain.MapRoot(main); // map main branch to domain root
domain.MapSubDomain(main, "www");
domain.MapSubDomain(dev);

var amplifyApp App
var main Branch
var dev Branch


domain := amplifyApp.AddDomain(jsii.String("example.com"), &DomainOptions{
	EnableAutoSubdomain: jsii.Boolean(true),
	 // in case subdomains should be auto registered for branches
	AutoSubdomainCreationPatterns: []*string{
		jsii.String("*"),
		jsii.String("pr*"),
	},
})
domain.MapRoot(main) // map main branch to domain root
domain.MapSubDomain(main, jsii.String("www"))
domain.MapSubDomain(dev)

To specify a custom certificate for your custom domain use the customCertificate property:

declare const customCertificate: acm.Certificate;
declare const amplifyApp: amplify.App;

const domain = amplifyApp.addDomain('example.com', {
  customCertificate, // set your custom certificate
});

# custom_certificate: acm.Certificate
# amplify_app: amplify.App


domain = amplify_app.add_domain("example.com",
    custom_certificate=custom_certificate
)

Certificate customCertificate;
App amplifyApp;


Domain domain = amplifyApp.addDomain("example.com", DomainOptions.builder()
        .customCertificate(customCertificate)
        .build());

Certificate customCertificate;
App amplifyApp;


var domain = amplifyApp.AddDomain("example.com", new DomainOptions {
    CustomCertificate = customCertificate
});

var customCertificate Certificate
var amplifyApp App


domain := amplifyApp.AddDomain(jsii.String("example.com"), &DomainOptions{
	CustomCertificate: CustomCertificate,
})

Restricting access

Password protect the app with basic auth by specifying the basicAuth prop.

Use BasicAuth.fromCredentials when referencing an existing secret:

const amplifyApp = new amplify.App(this, 'MyApp', {
  sourceCodeProvider: new amplify.GitHubSourceCodeProvider({
    owner: '<user>',
    repository: '<repo>',
    oauthToken: SecretValue.secretsManager('my-github-token'),
  }),
  basicAuth: amplify.BasicAuth.fromCredentials('username', SecretValue.secretsManager('my-github-token')),
});

amplify_app = amplify.App(self, "MyApp",
    source_code_provider=amplify.GitHubSourceCodeProvider(
        owner="<user>",
        repository="<repo>",
        oauth_token=SecretValue.secrets_manager("my-github-token")
    ),
    basic_auth=amplify.BasicAuth.from_credentials("username", SecretValue.secrets_manager("my-github-token"))
)

App amplifyApp = App.Builder.create(this, "MyApp")
        .sourceCodeProvider(GitHubSourceCodeProvider.Builder.create()
                .owner("<user>")
                .repository("<repo>")
                .oauthToken(SecretValue.secretsManager("my-github-token"))
                .build())
        .basicAuth(BasicAuth.fromCredentials("username", SecretValue.secretsManager("my-github-token")))
        .build();

var amplifyApp = new App(this, "MyApp", new AppProps {
    SourceCodeProvider = new GitHubSourceCodeProvider(new GitHubSourceCodeProviderProps {
        Owner = "<user>",
        Repository = "<repo>",
        OauthToken = SecretValue.SecretsManager("my-github-token")
    }),
    BasicAuth = BasicAuth.FromCredentials("username", SecretValue.SecretsManager("my-github-token"))
});

amplifyApp := amplify.NewApp(this, jsii.String("MyApp"), &AppProps{
	SourceCodeProvider: amplify.NewGitHubSourceCodeProvider(&GitHubSourceCodeProviderProps{
		Owner: jsii.String("<user>"),
		Repository: jsii.String("<repo>"),
		OauthToken: awscdk.SecretValue_SecretsManager(jsii.String("my-github-token")),
	}),
	BasicAuth: amplify.BasicAuth_FromCredentials(jsii.String("username"), awscdk.SecretValue_*SecretsManager(jsii.String("my-github-token"))),
})

Use BasicAuth.fromGeneratedPassword to generate a password in Secrets Manager:

const amplifyApp = new amplify.App(this, 'MyApp', {
  sourceCodeProvider: new amplify.GitHubSourceCodeProvider({
    owner: '<user>',
    repository: '<repo>',
    oauthToken: SecretValue.secretsManager('my-github-token'),
  }),
  basicAuth: amplify.BasicAuth.fromGeneratedPassword('username'),
});

amplify_app = amplify.App(self, "MyApp",
    source_code_provider=amplify.GitHubSourceCodeProvider(
        owner="<user>",
        repository="<repo>",
        oauth_token=SecretValue.secrets_manager("my-github-token")
    ),
    basic_auth=amplify.BasicAuth.from_generated_password("username")
)

App amplifyApp = App.Builder.create(this, "MyApp")
        .sourceCodeProvider(GitHubSourceCodeProvider.Builder.create()
                .owner("<user>")
                .repository("<repo>")
                .oauthToken(SecretValue.secretsManager("my-github-token"))
                .build())
        .basicAuth(BasicAuth.fromGeneratedPassword("username"))
        .build();

var amplifyApp = new App(this, "MyApp", new AppProps {
    SourceCodeProvider = new GitHubSourceCodeProvider(new GitHubSourceCodeProviderProps {
        Owner = "<user>",
        Repository = "<repo>",
        OauthToken = SecretValue.SecretsManager("my-github-token")
    }),
    BasicAuth = BasicAuth.FromGeneratedPassword("username")
});

amplifyApp := amplify.NewApp(this, jsii.String("MyApp"), &AppProps{
	SourceCodeProvider: amplify.NewGitHubSourceCodeProvider(&GitHubSourceCodeProviderProps{
		Owner: jsii.String("<user>"),
		Repository: jsii.String("<repo>"),
		OauthToken: awscdk.SecretValue_SecretsManager(jsii.String("my-github-token")),
	}),
	BasicAuth: amplify.BasicAuth_FromGeneratedPassword(jsii.String("username")),
})

Basic auth can be added to specific branches:

declare const amplifyApp: amplify.App;
amplifyApp.addBranch('feature/next', {
  basicAuth: amplify.BasicAuth.fromGeneratedPassword('username'),
});

# amplify_app: amplify.App

amplify_app.add_branch("feature/next",
    basic_auth=amplify.BasicAuth.from_generated_password("username")
)

App amplifyApp;

amplifyApp.addBranch("feature/next", BranchOptions.builder()
        .basicAuth(BasicAuth.fromGeneratedPassword("username"))
        .build());

App amplifyApp;

amplifyApp.AddBranch("feature/next", new BranchOptions {
    BasicAuth = BasicAuth.FromGeneratedPassword("username")
});

var amplifyApp App

amplifyApp.AddBranch(jsii.String("feature/next"), &BranchOptions{
	BasicAuth: amplify.BasicAuth_FromGeneratedPassword(jsii.String("username")),
})

Automatically creating and deleting branches

Use the autoBranchCreation and autoBranchDeletion props to control creation/deletion of branches:

const amplifyApp = new amplify.App(this, 'MyApp', {
  sourceCodeProvider: new amplify.GitHubSourceCodeProvider({
    owner: '<user>',
    repository: '<repo>',
    oauthToken: SecretValue.secretsManager('my-github-token'),
  }),
  autoBranchCreation: { // Automatically connect branches that match a pattern set
    patterns: ['feature/*', 'test/*'],
  },
  autoBranchDeletion: true, // Automatically disconnect a branch when you delete a branch from your repository
});

amplify_app = amplify.App(self, "MyApp",
    source_code_provider=amplify.GitHubSourceCodeProvider(
        owner="<user>",
        repository="<repo>",
        oauth_token=SecretValue.secrets_manager("my-github-token")
    ),
    auto_branch_creation=amplify.AutoBranchCreation( # Automatically connect branches that match a pattern set
        patterns=["feature/*", "test/*"]),
    auto_branch_deletion=True
)

App amplifyApp = App.Builder.create(this, "MyApp")
        .sourceCodeProvider(GitHubSourceCodeProvider.Builder.create()
                .owner("<user>")
                .repository("<repo>")
                .oauthToken(SecretValue.secretsManager("my-github-token"))
                .build())
        .autoBranchCreation(AutoBranchCreation.builder() // Automatically connect branches that match a pattern set
                .patterns(List.of("feature/*", "test/*")).build())
        .autoBranchDeletion(true)
        .build();

var amplifyApp = new App(this, "MyApp", new AppProps {
    SourceCodeProvider = new GitHubSourceCodeProvider(new GitHubSourceCodeProviderProps {
        Owner = "<user>",
        Repository = "<repo>",
        OauthToken = SecretValue.SecretsManager("my-github-token")
    }),
    AutoBranchCreation = new AutoBranchCreation {  // Automatically connect branches that match a pattern set
        Patterns = new [] { "feature/*", "test/*" } },
    AutoBranchDeletion = true
});

amplifyApp := amplify.NewApp(this, jsii.String("MyApp"), &AppProps{
	SourceCodeProvider: amplify.NewGitHubSourceCodeProvider(&GitHubSourceCodeProviderProps{
		Owner: jsii.String("<user>"),
		Repository: jsii.String("<repo>"),
		OauthToken: awscdk.SecretValue_SecretsManager(jsii.String("my-github-token")),
	}),
	AutoBranchCreation: &AutoBranchCreation{
		 // Automatically connect branches that match a pattern set
		Patterns: []*string{
			jsii.String("feature/*"),
			jsii.String("test/*"),
		},
	},
	AutoBranchDeletion: jsii.Boolean(true),
})

Adding custom response headers

Use the customResponseHeaders prop to configure custom response headers for an Amplify app:

const amplifyApp = new amplify.App(this, 'App', {
  sourceCodeProvider: new amplify.GitHubSourceCodeProvider({
    owner: '<user>',
    repository: '<repo>',
    oauthToken: SecretValue.secretsManager('my-github-token'),
  }),
  customResponseHeaders: [
    {
      pattern: '*.json',
      headers: {
        'custom-header-name-1': 'custom-header-value-1',
        'custom-header-name-2': 'custom-header-value-2',
      },
    },
    {
      pattern: '/path/*',
      headers: {
        'custom-header-name-1': 'custom-header-value-2',
      },
    },
  ],
});

amplify_app = amplify.App(self, "App",
    source_code_provider=amplify.GitHubSourceCodeProvider(
        owner="<user>",
        repository="<repo>",
        oauth_token=SecretValue.secrets_manager("my-github-token")
    ),
    custom_response_headers=[amplify.CustomResponseHeader(
        pattern="*.json",
        headers={
            "custom-header-name-1": "custom-header-value-1",
            "custom-header-name-2": "custom-header-value-2"
        }
    ), amplify.CustomResponseHeader(
        pattern="/path/*",
        headers={
            "custom-header-name-1": "custom-header-value-2"
        }
    )
    ]
)

App amplifyApp = App.Builder.create(this, "App")
        .sourceCodeProvider(GitHubSourceCodeProvider.Builder.create()
                .owner("<user>")
                .repository("<repo>")
                .oauthToken(SecretValue.secretsManager("my-github-token"))
                .build())
        .customResponseHeaders(List.of(CustomResponseHeader.builder()
                .pattern("*.json")
                .headers(Map.of(
                        "custom-header-name-1", "custom-header-value-1",
                        "custom-header-name-2", "custom-header-value-2"))
                .build(), CustomResponseHeader.builder()
                .pattern("/path/*")
                .headers(Map.of(
                        "custom-header-name-1", "custom-header-value-2"))
                .build()))
        .build();

var amplifyApp = new App(this, "App", new AppProps {
    SourceCodeProvider = new GitHubSourceCodeProvider(new GitHubSourceCodeProviderProps {
        Owner = "<user>",
        Repository = "<repo>",
        OauthToken = SecretValue.SecretsManager("my-github-token")
    }),
    CustomResponseHeaders = new [] { new CustomResponseHeader {
        Pattern = "*.json",
        Headers = new Dictionary<string, string> {
            { "custom-header-name-1", "custom-header-value-1" },
            { "custom-header-name-2", "custom-header-value-2" }
        }
    }, new CustomResponseHeader {
        Pattern = "/path/*",
        Headers = new Dictionary<string, string> {
            { "custom-header-name-1", "custom-header-value-2" }
        }
    } }
});

amplifyApp := amplify.NewApp(this, jsii.String("App"), &AppProps{
	SourceCodeProvider: amplify.NewGitHubSourceCodeProvider(&GitHubSourceCodeProviderProps{
		Owner: jsii.String("<user>"),
		Repository: jsii.String("<repo>"),
		OauthToken: awscdk.SecretValue_SecretsManager(jsii.String("my-github-token")),
	}),
	CustomResponseHeaders: []CustomResponseHeader{
		&CustomResponseHeader{
			Pattern: jsii.String("*.json"),
			Headers: map[string]*string{
				"custom-header-name-1": jsii.String("custom-header-value-1"),
				"custom-header-name-2": jsii.String("custom-header-value-2"),
			},
		},
		&CustomResponseHeader{
			Pattern: jsii.String("/path/*"),
			Headers: map[string]*string{
				"custom-header-name-1": jsii.String("custom-header-value-2"),
			},
		},
	},
})

If the app uses a monorepo structure, define which appRoot from the build spec the custom response headers should apply to by using the appRoot property:

import * as codebuild from 'aws-cdk-lib/aws-codebuild';

const amplifyApp = new amplify.App(this, 'App', {
  sourceCodeProvider: new amplify.GitHubSourceCodeProvider({
    owner: '<user>',
    repository: '<repo>',
    oauthToken: SecretValue.secretsManager('my-github-token'),
  }),
  buildSpec: codebuild.BuildSpec.fromObjectToYaml({
    version: '1.0',
    applications: [
      {
        appRoot: 'frontend',
        frontend: {
          phases: {
            preBuild: {
              commands: ['npm install'],
            },
            build: {
              commands: ['npm run build'],
            },
          },
        },
      },
      {
        appRoot: 'backend',
        backend: {
          phases: {
            preBuild: {
              commands: ['npm install'],
            },
            build: {
              commands: ['npm run build'],
            },
          },
        },
      },
    ],
  }),
  customResponseHeaders: [
    {
      appRoot: 'frontend',
      pattern: '*.json',
      headers: {
        'custom-header-name-1': 'custom-header-value-1',
        'custom-header-name-2': 'custom-header-value-2',
      },
    },
    {
      appRoot: 'backend',
      pattern: '/path/*',
      headers: {
        'custom-header-name-1': 'custom-header-value-2',
      },
    },
  ],
});

import aws_cdk.aws_codebuild as codebuild


amplify_app = amplify.App(self, "App",
    source_code_provider=amplify.GitHubSourceCodeProvider(
        owner="<user>",
        repository="<repo>",
        oauth_token=SecretValue.secrets_manager("my-github-token")
    ),
    build_spec=codebuild.BuildSpec.from_object_to_yaml({
        "version": "1.0",
        "applications": [{
            "app_root": "frontend",
            "frontend": {
                "phases": {
                    "pre_build": {
                        "commands": ["npm install"]
                    },
                    "build": {
                        "commands": ["npm run build"]
                    }
                }
            }
        }, {
            "app_root": "backend",
            "backend": {
                "phases": {
                    "pre_build": {
                        "commands": ["npm install"]
                    },
                    "build": {
                        "commands": ["npm run build"]
                    }
                }
            }
        }
        ]
    }),
    custom_response_headers=[amplify.CustomResponseHeader(
        app_root="frontend",
        pattern="*.json",
        headers={
            "custom-header-name-1": "custom-header-value-1",
            "custom-header-name-2": "custom-header-value-2"
        }
    ), amplify.CustomResponseHeader(
        app_root="backend",
        pattern="/path/*",
        headers={
            "custom-header-name-1": "custom-header-value-2"
        }
    )
    ]
)

import software.amazon.awscdk.services.codebuild.*;


App amplifyApp = App.Builder.create(this, "App")
        .sourceCodeProvider(GitHubSourceCodeProvider.Builder.create()
                .owner("<user>")
                .repository("<repo>")
                .oauthToken(SecretValue.secretsManager("my-github-token"))
                .build())
        .buildSpec(BuildSpec.fromObjectToYaml(Map.of(
                "version", "1.0",
                "applications", List.of(Map.of(
                        "appRoot", "frontend",
                        "frontend", Map.of(
                                "phases", Map.of(
                                        "preBuild", Map.of(
                                                "commands", List.of("npm install")),
                                        "build", Map.of(
                                                "commands", List.of("npm run build"))))), Map.of(
                        "appRoot", "backend",
                        "backend", Map.of(
                                "phases", Map.of(
                                        "preBuild", Map.of(
                                                "commands", List.of("npm install")),
                                        "build", Map.of(
                                                "commands", List.of("npm run build")))))))))
        .customResponseHeaders(List.of(CustomResponseHeader.builder()
                .appRoot("frontend")
                .pattern("*.json")
                .headers(Map.of(
                        "custom-header-name-1", "custom-header-value-1",
                        "custom-header-name-2", "custom-header-value-2"))
                .build(), CustomResponseHeader.builder()
                .appRoot("backend")
                .pattern("/path/*")
                .headers(Map.of(
                        "custom-header-name-1", "custom-header-value-2"))
                .build()))
        .build();

using Amazon.CDK.AWS.CodeBuild;


var amplifyApp = new App(this, "App", new AppProps {
    SourceCodeProvider = new GitHubSourceCodeProvider(new GitHubSourceCodeProviderProps {
        Owner = "<user>",
        Repository = "<repo>",
        OauthToken = SecretValue.SecretsManager("my-github-token")
    }),
    BuildSpec = BuildSpec.FromObjectToYaml(new Dictionary<string, object> {
        { "version", "1.0" },
        { "applications", new [] { new Dictionary<string, object> {
            { "appRoot", "frontend" },
            { "frontend", new Struct {
                Phases = new Struct {
                    PreBuild = new Struct {
                        Commands = new [] { "npm install" }
                    },
                    Build = new Struct {
                        Commands = new [] { "npm run build" }
                    }
                }
            } }
        }, new Dictionary<string, object> {
            { "appRoot", "backend" },
            { "backend", new Struct {
                Phases = new Struct {
                    PreBuild = new Struct {
                        Commands = new [] { "npm install" }
                    },
                    Build = new Struct {
                        Commands = new [] { "npm run build" }
                    }
                }
            } }
        } } }
    }),
    CustomResponseHeaders = new [] { new CustomResponseHeader {
        AppRoot = "frontend",
        Pattern = "*.json",
        Headers = new Dictionary<string, string> {
            { "custom-header-name-1", "custom-header-value-1" },
            { "custom-header-name-2", "custom-header-value-2" }
        }
    }, new CustomResponseHeader {
        AppRoot = "backend",
        Pattern = "/path/*",
        Headers = new Dictionary<string, string> {
            { "custom-header-name-1", "custom-header-value-2" }
        }
    } }
});

import codebuild "github.com/aws/aws-cdk-go/awscdk"


amplifyApp := amplify.NewApp(this, jsii.String("App"), &AppProps{
	SourceCodeProvider: amplify.NewGitHubSourceCodeProvider(&GitHubSourceCodeProviderProps{
		Owner: jsii.String("<user>"),
		Repository: jsii.String("<repo>"),
		OauthToken: awscdk.SecretValue_SecretsManager(jsii.String("my-github-token")),
	}),
	BuildSpec: codebuild.BuildSpec_FromObjectToYaml(map[string]interface{}{
		"version": jsii.String("1.0"),
		"applications": []interface{}{
			map[string]interface{}{
				"appRoot": jsii.String("frontend"),
				"frontend": map[string]map[string]map[string][]*string{
					"phases": map[string]map[string][]*string{
						"preBuild": map[string][]*string{
							"commands": []*string{
								jsii.String("npm install"),
							},
						},
						"build": map[string][]*string{
							"commands": []*string{
								jsii.String("npm run build"),
							},
						},
					},
				},
			},
			map[string]interface{}{
				"appRoot": jsii.String("backend"),
				"backend": map[string]map[string]map[string][]*string{
					"phases": map[string]map[string][]*string{
						"preBuild": map[string][]*string{
							"commands": []*string{
								jsii.String("npm install"),
							},
						},
						"build": map[string][]*string{
							"commands": []*string{
								jsii.String("npm run build"),
							},
						},
					},
				},
			},
		},
	}),
	CustomResponseHeaders: []CustomResponseHeader{
		&CustomResponseHeader{
			AppRoot: jsii.String("frontend"),
			Pattern: jsii.String("*.json"),
			Headers: map[string]*string{
				"custom-header-name-1": jsii.String("custom-header-value-1"),
				"custom-header-name-2": jsii.String("custom-header-value-2"),
			},
		},
		&CustomResponseHeader{
			AppRoot: jsii.String("backend"),
			Pattern: jsii.String("/path/*"),
			Headers: map[string]*string{
				"custom-header-name-1": jsii.String("custom-header-value-2"),
			},
		},
	},
})

Configure server side rendering when hosting app

Setting the platform field on the Amplify App construct can be used to control whether the app will host only static assets or server side rendered assets in addition to static. By default, the value is set to WEB (static only), however, server side rendering can be turned on by setting to WEB_COMPUTE as follows:

const amplifyApp = new amplify.App(this, 'MyApp', {
  platform: amplify.Platform.WEB_COMPUTE,
});

amplify_app = amplify.App(self, "MyApp",
    platform=amplify.Platform.WEB_COMPUTE
)

App amplifyApp = App.Builder.create(this, "MyApp")
        .platform(Platform.WEB_COMPUTE)
        .build();

var amplifyApp = new App(this, "MyApp", new AppProps {
    Platform = Platform.WEB_COMPUTE
});

amplifyApp := amplify.NewApp(this, jsii.String("MyApp"), &AppProps{
	Platform: amplify.Platform_WEB_COMPUTE,
})

Compute role

This integration, enables you to assign an IAM role to the Amplify SSR Compute service to allow your server-side rendered (SSR) application to securely access specific AWS resources based on the role's permissions.

For example, you can allow your app's SSR compute functions to securely access other AWS services or resources, such as Amazon Bedrock or an Amazon S3 bucket, based on the permissions defined in the assigned IAM role.

For more information, see Adding an SSR Compute role to allow access to AWS resources.

By default, a new role is created when platform is Platform.WEB_COMPUTE or Platform.WEB_DYNAMIC. If you want to assign an IAM role to the APP, set compute to the role:

declare const computeRole: iam.Role;

const amplifyApp = new amplify.App(this, 'MyApp', {
  platform: amplify.Platform.WEB_COMPUTE,
  computeRole,
});

# compute_role: iam.Role


amplify_app = amplify.App(self, "MyApp",
    platform=amplify.Platform.WEB_COMPUTE,
    compute_role=compute_role
)

Role computeRole;


App amplifyApp = App.Builder.create(this, "MyApp")
        .platform(Platform.WEB_COMPUTE)
        .computeRole(computeRole)
        .build();

Role computeRole;


var amplifyApp = new App(this, "MyApp", new AppProps {
    Platform = Platform.WEB_COMPUTE,
    ComputeRole = computeRole
});

var computeRole Role


amplifyApp := amplify.NewApp(this, jsii.String("MyApp"), &AppProps{
	Platform: amplify.Platform_WEB_COMPUTE,
	ComputeRole: ComputeRole,
})

It is also possible to override the compute role for a specific branch by setting computeRole in Branch:

declare const computeRole: iam.Role;
declare const amplifyApp: amplify.App

const branch = amplifyApp.addBranch("dev", { computeRole });

# compute_role: iam.Role
# amplify_app: amplify.App


branch = amplify_app.add_branch("dev", compute_role=compute_role)

Role computeRole;
App amplifyApp;


Branch branch = amplifyApp.addBranch("dev", BranchOptions.builder().computeRole(computeRole).build());

Role computeRole;
App amplifyApp;


var branch = amplifyApp.AddBranch("dev", new BranchOptions { ComputeRole = computeRole });

var computeRole Role
var amplifyApp App


branch := amplifyApp.AddBranch(jsii.String("dev"), &BranchOptions{
	ComputeRole: ComputeRole,
})

Cache Config

Amplify uses Amazon CloudFront to manage the caching configuration for your hosted applications. A cache configuration is applied to each app to optimize for the best performance.

Setting the cacheConfigType field on the Amplify App construct can be used to control cache configuration. By default, the value is set to AMPLIFY_MANAGED. If you want to exclude all cookies from the cache key, set AMPLIFY_MANAGED_NO_COOKIES.

For more information, see Managing the cache configuration for an app.

const amplifyApp = new amplify.App(this, 'MyApp', {
  cacheConfigType: amplify.CacheConfigType.AMPLIFY_MANAGED_NO_COOKIES,
});

amplify_app = amplify.App(self, "MyApp",
    cache_config_type=amplify.CacheConfigType.AMPLIFY_MANAGED_NO_COOKIES
)

App amplifyApp = App.Builder.create(this, "MyApp")
        .cacheConfigType(CacheConfigType.AMPLIFY_MANAGED_NO_COOKIES)
        .build();

var amplifyApp = new App(this, "MyApp", new AppProps {
    CacheConfigType = CacheConfigType.AMPLIFY_MANAGED_NO_COOKIES
});

amplifyApp := amplify.NewApp(this, jsii.String("MyApp"), &AppProps{
	CacheConfigType: amplify.CacheConfigType_AMPLIFY_MANAGED_NO_COOKIES,
})

Build Compute Type

You can specify the build compute type by setting the buildComputeType property.

For more information, see Configuring the build instance for an Amplify application.

const amplifyApp = new amplify.App(this, 'MyApp', {
  buildComputeType: amplify.BuildComputeType.LARGE_16GB,
});

amplify_app = amplify.App(self, "MyApp",
    build_compute_type=amplify.BuildComputeType.LARGE_16GB
)

App amplifyApp = App.Builder.create(this, "MyApp")
        .buildComputeType(BuildComputeType.LARGE_16GB)
        .build();

var amplifyApp = new App(this, "MyApp", new AppProps {
    BuildComputeType = BuildComputeType.LARGE_16GB
});

amplifyApp := amplify.NewApp(this, jsii.String("MyApp"), &AppProps{
	BuildComputeType: amplify.BuildComputeType_LARGE_16GB,
})

Deploying Assets

sourceCodeProvider is optional; when this is not specified the Amplify app can be deployed to using .zip packages. The asset property can be used to deploy S3 assets to Amplify as part of the CDK:

import * as assets from 'aws-cdk-lib/aws-s3-assets';

declare const asset: assets.Asset;
declare const amplifyApp: amplify.App;
const branch = amplifyApp.addBranch("dev", { asset: asset });

import aws_cdk.aws_s3_assets as assets

# asset: assets.Asset
# amplify_app: amplify.App

branch = amplify_app.add_branch("dev", asset=asset)

import software.amazon.awscdk.services.s3.assets.*;

Asset asset;
App amplifyApp;

Branch branch = amplifyApp.addBranch("dev", BranchOptions.builder().asset(asset).build());

using Amazon.CDK.AWS.S3.Assets;

Asset asset;
App amplifyApp;

var branch = amplifyApp.AddBranch("dev", new BranchOptions { Asset = asset });

import assets "github.com/aws/aws-cdk-go/awscdk"

var asset Asset
var amplifyApp App

branch := amplifyApp.AddBranch(jsii.String("dev"), &BranchOptions{
	Asset: asset,
})

Skew protection for Amplify Deployments

Deployment skew protection is available to Amplify applications to eliminate version skew issues between client and servers in web applications. When you apply skew protection to an Amplify application, you can ensure that your clients always interact with the correct version of server-side assets, regardless of when a deployment occurs.

For more information, see Skew protection for Amplify deployments.

To enable skew protection, set the skewProtection property to true:

declare const amplifyApp: amplify.App;
const branch = amplifyApp.addBranch("dev", { skewProtection: true });

# amplify_app: amplify.App

branch = amplify_app.add_branch("dev", skew_protection=True)

App amplifyApp;

Branch branch = amplifyApp.addBranch("dev", BranchOptions.builder().skewProtection(true).build());

App amplifyApp;

var branch = amplifyApp.AddBranch("dev", new BranchOptions { SkewProtection = true });

var amplifyApp App

branch := amplifyApp.AddBranch(jsii.String("dev"), &BranchOptions{
	SkewProtection: jsii.Boolean(true),
})

Types

Name	Kind	Summary
App	Construct (L2)	An Amplify Console application.
Branch	Construct (L2)	An Amplify Console branch.
Domain	Construct (L2)	An Amplify Console domain.
AppProps	Struct	Properties for an App.
AutoBranchCreation	Struct	Auto branch creation configuration.
BasicAuth	Class	Basic Auth configuration.
BasicAuthConfig	Struct	A Basic Auth configuration.
BasicAuthProps	Struct	Properties for a BasicAuth.
BranchOptions	Struct	Options to add a branch to an application.
BranchProps	Struct	Properties for a Branch.
BuildComputeType	Enum	Specifies the size of the build instance.
CacheConfigType	Enum	The type of cache configuration to use for an Amplify app.
CodeCommitSourceCodeProvider	Class	CodeCommit source code provider.
CodeCommitSourceCodeProviderProps	Struct	Properties for a CodeCommit source code provider.
CustomResponseHeader	Struct	Custom response header of an Amplify App.
CustomRule	Class	Custom rewrite/redirect rule for an Amplify App.
CustomRuleOptions	Struct	Options for a custom rewrite/redirect rule for an Amplify App.
DomainOptions	Struct	Options to add a domain to an application.
DomainProps	Struct	Properties for a Domain.
GitHubSourceCodeProvider	Class	GitHub source code provider.
GitHubSourceCodeProviderProps	Struct	Properties for a GitHub source code provider.
GitLabSourceCodeProvider	Class	GitLab source code provider.
GitLabSourceCodeProviderProps	Struct	Properties for a GitLab source code provider.
IApp	Interface	An Amplify Console application.
IBranch	Interface	A branch.
ISourceCodeProvider	Interface	A source code provider.
Platform	Enum	Available hosting platforms to use on the App.
RedirectStatus	Enum	The status code for a URL rewrite or redirect rule.
SourceCodeProviderConfig	Struct	Configuration for the source code provider.
SubDomain	Struct	Sub domain settings.