App class

Provides an Amplify App resource, a fullstack serverless app hosted on the AWS Amplify Console.

> Note: When you create/update an Amplify App from the provider, you may end up with the error "BadRequestException: You should at least provide one valid token" because of authentication issues. See the section "Repository with Tokens" below.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.amplify.App("example", {
    customRules: [{
        source: "/<*>",
        status: "404",
        target: "/index.html",
    }],
    name: "example",
    repository: "https://github.com/example/app",
    buildSpec: `version: 0.1
frontend:
  phases:
    preBuild:
      commands:
        - yarn install
    build:
      commands:
        - yarn run build
  artifacts:
    baseDirectory: build
    files:
      - '**/*'
  cache:
    paths:
      - node_modules/**/*
`,
    environmentVariables: {
        ENV: "test",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.amplify.App("example",
    custom_rules=[{
        "source": "/<*>",
        "status": "404",
        "target": "/index.html",
    }],
    name="example",
    repository="https://github.com/example/app",
    build_spec="""version: 0.1
frontend:
  phases:
    preBuild:
      commands:
        - yarn install
    build:
      commands:
        - yarn run build
  artifacts:
    baseDirectory: build
    files:
      - '**/*'
  cache:
    paths:
      - node_modules/**/*
""",
    environment_variables={
        "ENV": "test",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amplify.App("example", new()
    {
        CustomRules = new[]
        {
            new Aws.Amplify.Inputs.AppCustomRuleArgs
            {
                Source = "/<*>",
                Status = "404",
                Target = "/index.html",
            },
        },
        Name = "example",
        Repository = "https://github.com/example/app",
        BuildSpec = @"version: 0.1
frontend:
  phases:
    preBuild:
      commands:
        - yarn install
    build:
      commands:
        - yarn run build
  artifacts:
    baseDirectory: build
    files:
      - '**/*'
  cache:
    paths:
      - node_modules/**/*
",
        EnvironmentVariables =
        {
            { "ENV", "test" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amplify"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := amplify.NewApp(ctx, "example", &amplify.AppArgs{
			CustomRules: amplify.AppCustomRuleArray{
				&amplify.AppCustomRuleArgs{
					Source: pulumi.String("/<*>"),
					Status: pulumi.String("404"),
					Target: pulumi.String("/index.html"),
				},
			},
			Name:       pulumi.String("example"),
			Repository: pulumi.String("https://github.com/example/app"),
			BuildSpec: pulumi.String(`version: 0.1
frontend:
  phases:
    preBuild:
      commands:
        - yarn install
    build:
      commands:
        - yarn run build
  artifacts:
    baseDirectory: build
    files:
      - '**/*'
  cache:
    paths:
      - node_modules/**/*
`),
			EnvironmentVariables: pulumi.StringMap{
				"ENV": pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_amplify_app" "example" {
  custom_rules {
    source = "/<*>"
    status = "404"
    target = "/index.html"
  }
  name       = "example"
  repository = "https://github.com/example/app"
  build_spec = "version: 0.1\nfrontend:\n  phases:\n    preBuild:\n      commands:\n        - yarn install\n    build:\n      commands:\n        - yarn run build\n  artifacts:\n    baseDirectory: build\n    files:\n      - '**/*'\n  cache:\n    paths:\n      - node_modules/**/*\n"
  environment_variables = {
    "ENV" = "test"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.amplify.App;
import com.pulumi.aws.amplify.AppArgs;
import com.pulumi.aws.amplify.inputs.AppCustomRuleArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new App("example", AppArgs.builder()
            .customRules(AppCustomRuleArgs.builder()
                .source("/<*>")
                .status("404")
                .target("/index.html")
                .build())
            .name("example")
            .repository("https://github.com/example/app")
            .buildSpec("""
version: 0.1
frontend:
  phases:
    preBuild:
      commands:
        - yarn install
    build:
      commands:
        - yarn run build
  artifacts:
    baseDirectory: build
    files:
      - '**/*'
  cache:
    paths:
      - node_modules/**/*
            """)
            .environmentVariables(Map.of("ENV", "test"))
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      customRules:
        - source: /<*>
          status: '404'
          target: /index.html
      name: example
      repository: https://github.com/example/app
      buildSpec: |
        version: 0.1
        frontend:
          phases:
            preBuild:
              commands:
                - yarn install
            build:
              commands:
                - yarn run build
          artifacts:
            baseDirectory: build
            files:
              - '**/*'
          cache:
            paths:
              - node_modules/**/*
      environmentVariables:
        ENV: test

Repository with Tokens

If you create a new Amplify App with the repository argument, you also need to set oauthToken or accessToken for authentication. For GitHub, get a personal access token and set accessToken as follows:

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.amplify.App("example", {
    name: "example",
    repository: "https://github.com/example/app",
    accessToken: "...",
});
import pulumi
import pulumi_aws as aws

example = aws.amplify.App("example",
    name="example",
    repository="https://github.com/example/app",
    access_token="...")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amplify.App("example", new()
    {
        Name = "example",
        Repository = "https://github.com/example/app",
        AccessToken = "...",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amplify"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := amplify.NewApp(ctx, "example", &amplify.AppArgs{
			Name:        pulumi.String("example"),
			Repository:  pulumi.String("https://github.com/example/app"),
			AccessToken: pulumi.String("..."),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_amplify_app" "example" {
  name         = "example"
  repository   = "https://github.com/example/app"
  access_token = "..."
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.amplify.App;
import com.pulumi.aws.amplify.AppArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new App("example", AppArgs.builder()
            .name("example")
            .repository("https://github.com/example/app")
            .accessToken("...")
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      name: example
      repository: https://github.com/example/app
      accessToken: '...'

You can omit accessToken if you import an existing Amplify App created by the Amplify Console (using OAuth for authentication).

Auto Branch Creation

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.amplify.App("example", {
    autoBranchCreationConfig: {
        enableAutoBuild: true,
    },
    name: "example",
    enableAutoBranchCreation: true,
    autoBranchCreationPatterns: [
        "*",
        "*/**",
    ],
});
import pulumi
import pulumi_aws as aws

example = aws.amplify.App("example",
    auto_branch_creation_config={
        "enable_auto_build": True,
    },
    name="example",
    enable_auto_branch_creation=True,
    auto_branch_creation_patterns=[
        "*",
        "*/**",
    ])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amplify.App("example", new()
    {
        AutoBranchCreationConfig = new Aws.Amplify.Inputs.AppAutoBranchCreationConfigArgs
        {
            EnableAutoBuild = true,
        },
        Name = "example",
        EnableAutoBranchCreation = true,
        AutoBranchCreationPatterns = new[]
        {
            "*",
            "*/**",
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amplify"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := amplify.NewApp(ctx, "example", &amplify.AppArgs{
			AutoBranchCreationConfig: &amplify.AppAutoBranchCreationConfigArgs{
				EnableAutoBuild: pulumi.Bool(true),
			},
			Name:                     pulumi.String("example"),
			EnableAutoBranchCreation: pulumi.Bool(true),
			AutoBranchCreationPatterns: pulumi.StringArray{
				pulumi.String("*"),
				pulumi.String("*/**"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_amplify_app" "example" {
  auto_branch_creation_config = {
    enable_auto_build = true
  }
  # Enable auto build for the created branch.
  name                        = "example"
  enable_auto_branch_creation = true
  # The default patterns added by the Amplify Console.
  auto_branch_creation_patterns = ["*", "*/**"]
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.amplify.App;
import com.pulumi.aws.amplify.AppArgs;
import com.pulumi.aws.amplify.inputs.AppAutoBranchCreationConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new App("example", AppArgs.builder()
            .autoBranchCreationConfig(AppAutoBranchCreationConfigArgs.builder()
                .enableAutoBuild(true)
                .build())
            .name("example")
            .enableAutoBranchCreation(true)
            .autoBranchCreationPatterns(
                "*",
                "*/**")
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      autoBranchCreationConfig:
        enableAutoBuild: true
      name: example
      enableAutoBranchCreation: true # The default patterns added by the Amplify Console.
      autoBranchCreationPatterns:
        - '*'
        - '*/**'

Basic Authorization

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as std from "@pulumi/std";

const example = new aws.amplify.App("example", {
    name: "example",
    enableBasicAuth: true,
    basicAuthCredentials: std.base64encode({
        input: "username1:password1",
    }).then(invoke => invoke.result),
});
import pulumi
import pulumi_aws as aws
import pulumi_std as std

example = aws.amplify.App("example",
    name="example",
    enable_basic_auth=True,
    basic_auth_credentials=std.base64encode(input="username1:password1").result)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amplify.App("example", new()
    {
        Name = "example",
        EnableBasicAuth = true,
        BasicAuthCredentials = Std.Base64encode.Invoke(new()
        {
            Input = "username1:password1",
        }).Apply(invoke => invoke.Result),
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amplify"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeBase64encode, err := std.Base64encode(ctx, &std.Base64encodeArgs{
			Input: "username1:password1",
		}, nil)
		if err != nil {
			return err
		}
		_, err = amplify.NewApp(ctx, "example", &amplify.AppArgs{
			Name:                 pulumi.String("example"),
			EnableBasicAuth:      pulumi.Bool(true),
			BasicAuthCredentials: pulumi.String(invokeBase64encode.Result),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
    std = {
      source = "pulumi/std"
    }
  }
}

resource "aws_amplify_app" "example" {
  name                   = "example"
  enable_basic_auth      = true
  basic_auth_credentials = base64encode("username1:password1")
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.amplify.App;
import com.pulumi.aws.amplify.AppArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.Base64encodeArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new App("example", AppArgs.builder()
            .name("example")
            .enableBasicAuth(true)
            .basicAuthCredentials(StdFunctions.base64encode(Base64encodeArgs.builder()
                .input("username1:password1")
                .build()).result())
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      name: example
      enableBasicAuth: true
      basicAuthCredentials:
        fn::invoke:
          function: std:base64encode
          arguments:
            input: username1:password1
          return: result

Rewrites and Redirects

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.amplify.App("example", {
    customRules: [
        {
            source: "/api/<*>",
            status: "200",
            target: "https://api.example.com/api/<*>",
        },
        {
            source: "</^[^.]+$|\\.(?!(css|gif|ico|jpg|js|png|txt|svg|woff|ttf|map|json)$)([^.]+$)/>",
            status: "200",
            target: "/index.html",
        },
    ],
    name: "example",
});
import pulumi
import pulumi_aws as aws

example = aws.amplify.App("example",
    custom_rules=[
        {
            "source": "/api/<*>",
            "status": "200",
            "target": "https://api.example.com/api/<*>",
        },
        {
            "source": "</^[^.]+$|\\.(?!(css|gif|ico|jpg|js|png|txt|svg|woff|ttf|map|json)$)([^.]+$)/>",
            "status": "200",
            "target": "/index.html",
        },
    ],
    name="example")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amplify.App("example", new()
    {
        CustomRules = new[]
        {
            new Aws.Amplify.Inputs.AppCustomRuleArgs
            {
                Source = "/api/<*>",
                Status = "200",
                Target = "https://api.example.com/api/<*>",
            },
            new Aws.Amplify.Inputs.AppCustomRuleArgs
            {
                Source = "</^[^.]+$|\\.(?!(css|gif|ico|jpg|js|png|txt|svg|woff|ttf|map|json)$)([^.]+$)/>",
                Status = "200",
                Target = "/index.html",
            },
        },
        Name = "example",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amplify"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := amplify.NewApp(ctx, "example", &amplify.AppArgs{
			CustomRules: amplify.AppCustomRuleArray{
				&amplify.AppCustomRuleArgs{
					Source: pulumi.String("/api/<*>"),
					Status: pulumi.String("200"),
					Target: pulumi.String("https://api.example.com/api/<*>"),
				},
				&amplify.AppCustomRuleArgs{
					Source: pulumi.String("</^[^.]+$|\\.(?!(css|gif|ico|jpg|js|png|txt|svg|woff|ttf|map|json)$)([^.]+$)/>"),
					Status: pulumi.String("200"),
					Target: pulumi.String("/index.html"),
				},
			},
			Name: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_amplify_app" "example" {
  custom_rules {
    source = "/api/<*>"
    status = "200"
    target = "https://api.example.com/api/<*>"
  }
  custom_rules {
    source = "</^[^.]+$|\\.(?!(css|gif|ico|jpg|js|png|txt|svg|woff|ttf|map|json)$)([^.]+$)/>"
    status = "200"
    target = "/index.html"
  }
  name = "example"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.amplify.App;
import com.pulumi.aws.amplify.AppArgs;
import com.pulumi.aws.amplify.inputs.AppCustomRuleArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new App("example", AppArgs.builder()
            .customRules(
                AppCustomRuleArgs.builder()
                    .source("/api/<*>")
                    .status("200")
                    .target("https://api.example.com/api/<*>")
                    .build(),
                AppCustomRuleArgs.builder()
                    .source("</^[^.]+$|\\.(?!(css|gif|ico|jpg|js|png|txt|svg|woff|ttf|map|json)$)([^.]+$)/>")
                    .status("200")
                    .target("/index.html")
                    .build())
            .name("example")
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      customRules:
        - source: /api/<*>
          status: '200'
          target: https://api.example.com/api/<*>
        - source: </^[^.]+$|\.(?!(css|gif|ico|jpg|js|png|txt|svg|woff|ttf|map|json)$)([^.]+$)/>
          status: '200'
          target: /index.html
      name: example

Custom Image

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.amplify.App("example", {
    name: "example",
    environmentVariables: {
        _CUSTOM_IMAGE: "node:16",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.amplify.App("example",
    name="example",
    environment_variables={
        "_CUSTOM_IMAGE": "node:16",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amplify.App("example", new()
    {
        Name = "example",
        EnvironmentVariables =
        {
            { "_CUSTOM_IMAGE", "node:16" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amplify"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := amplify.NewApp(ctx, "example", &amplify.AppArgs{
			Name: pulumi.String("example"),
			EnvironmentVariables: pulumi.StringMap{
				"_CUSTOM_IMAGE": pulumi.String("node:16"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_amplify_app" "example" {
  name = "example"
  environment_variables = {
    "_CUSTOM_IMAGE" = "node:16"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.amplify.App;
import com.pulumi.aws.amplify.AppArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new App("example", AppArgs.builder()
            .name("example")
            .environmentVariables(Map.of("_CUSTOM_IMAGE", "node:16"))
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      name: example
      environmentVariables:
        _CUSTOM_IMAGE: node:16

Custom Headers

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.amplify.App("example", {
    name: "example",
    customHeaders: `customHeaders:
  - pattern: '**'
    headers:
      - key: 'Strict-Transport-Security'
        value: 'max-age=31536000; includeSubDomains'
      - key: 'X-Frame-Options'
        value: 'SAMEORIGIN'
      - key: 'X-XSS-Protection'
        value: '1; mode=block'
      - key: 'X-Content-Type-Options'
        value: 'nosniff'
      - key: 'Content-Security-Policy'
        value: \\"default-src 'self'\\"
`,
});
import pulumi
import pulumi_aws as aws

example = aws.amplify.App("example",
    name="example",
    custom_headers="""customHeaders:
  - pattern: '**'
    headers:
      - key: 'Strict-Transport-Security'
        value: 'max-age=31536000; includeSubDomains'
      - key: 'X-Frame-Options'
        value: 'SAMEORIGIN'
      - key: 'X-XSS-Protection'
        value: '1; mode=block'
      - key: 'X-Content-Type-Options'
        value: 'nosniff'
      - key: 'Content-Security-Policy'
        value: \"default-src 'self'\"
""")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amplify.App("example", new()
    {
        Name = "example",
        CustomHeaders = @"customHeaders:
  - pattern: '**'
    headers:
      - key: 'Strict-Transport-Security'
        value: 'max-age=31536000; includeSubDomains'
      - key: 'X-Frame-Options'
        value: 'SAMEORIGIN'
      - key: 'X-XSS-Protection'
        value: '1; mode=block'
      - key: 'X-Content-Type-Options'
        value: 'nosniff'
      - key: 'Content-Security-Policy'
        value: \""default-src 'self'\""
",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amplify"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := amplify.NewApp(ctx, "example", &amplify.AppArgs{
			Name: pulumi.String("example"),
			CustomHeaders: pulumi.String(`customHeaders:
  - pattern: '**'
    headers:
      - key: 'Strict-Transport-Security'
        value: 'max-age=31536000; includeSubDomains'
      - key: 'X-Frame-Options'
        value: 'SAMEORIGIN'
      - key: 'X-XSS-Protection'
        value: '1; mode=block'
      - key: 'X-Content-Type-Options'
        value: 'nosniff'
      - key: 'Content-Security-Policy'
        value: \"default-src 'self'\"
`),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_amplify_app" "example" {
  name           = "example"
  custom_headers = "customHeaders:\n  - pattern: '**'\n    headers:\n      - key: 'Strict-Transport-Security'\n        value: 'max-age=31536000; includeSubDomains'\n      - key: 'X-Frame-Options'\n        value: 'SAMEORIGIN'\n      - key: 'X-XSS-Protection'\n        value: '1; mode=block'\n      - key: 'X-Content-Type-Options'\n        value: 'nosniff'\n      - key: 'Content-Security-Policy'\n        value: \\\"default-src 'self'\\\"\n"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.amplify.App;
import com.pulumi.aws.amplify.AppArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new App("example", AppArgs.builder()
            .name("example")
            .customHeaders("""
customHeaders:
  - pattern: '**'
    headers:
      - key: 'Strict-Transport-Security'
        value: 'max-age=31536000; includeSubDomains'
      - key: 'X-Frame-Options'
        value: 'SAMEORIGIN'
      - key: 'X-XSS-Protection'
        value: '1; mode=block'
      - key: 'X-Content-Type-Options'
        value: 'nosniff'
      - key: 'Content-Security-Policy'
        value: \"default-src 'self'\"
            """)
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      name: example
      customHeaders: |
        customHeaders:
          - pattern: '**'
            headers:
              - key: 'Strict-Transport-Security'
                value: 'max-age=31536000; includeSubDomains'
              - key: 'X-Frame-Options'
                value: 'SAMEORIGIN'
              - key: 'X-XSS-Protection'
                value: '1; mode=block'
              - key: 'X-Content-Type-Options'
                value: 'nosniff'
              - key: 'Content-Security-Policy'
                value: \"default-src 'self'\"

Job Config

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.amplify.App("example", {
    jobConfig: {
        buildComputeType: "STANDARD_8GB",
    },
    name: "example",
});
import pulumi
import pulumi_aws as aws

example = aws.amplify.App("example",
    job_config={
        "build_compute_type": "STANDARD_8GB",
    },
    name="example")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amplify.App("example", new()
    {
        JobConfig = new Aws.Amplify.Inputs.AppJobConfigArgs
        {
            BuildComputeType = "STANDARD_8GB",
        },
        Name = "example",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amplify"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := amplify.NewApp(ctx, "example", &amplify.AppArgs{
			JobConfig: &amplify.AppJobConfigArgs{
				BuildComputeType: pulumi.String("STANDARD_8GB"),
			},
			Name: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_amplify_app" "example" {
  job_config = {
    build_compute_type = "STANDARD_8GB"
  }
  name = "example"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.amplify.App;
import com.pulumi.aws.amplify.AppArgs;
import com.pulumi.aws.amplify.inputs.AppJobConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new App("example", AppArgs.builder()
            .jobConfig(AppJobConfigArgs.builder()
                .buildComputeType("STANDARD_8GB")
                .build())
            .name("example")
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      jobConfig:
        buildComputeType: STANDARD_8GB
      name: example

Import

Using pulumi import, import Amplify App using Amplify App ID (appId). For example:

$ pulumi import aws:amplify/app:App example d2ypk4k47z8u6

App ID can be obtained from App ARN (e.g., arn:aws:amplify:us-east-1:12345678:apps/d2ypk4k47z8u6).

Constructors

App(String name, {AppArgs? args, CustomResourceOptions? options})
Creates a new App. name The Pulumi resource name. args Arguments used to configure this App. The set of arguments for App. options Resource options controlling this resource's behavior.
App.reference(String urn)
Creates a typed reference to an existing App resource.

Properties

accessToken ↔ Output<String?>
Personal access token for a third-party source control system for an Amplify app. This token must have write access to the relevant repo to create a webhook and a read-only deploy key for the Amplify project. The token is not stored, so after applying this attribute can be removed and the setup token deleted.
latefinal
arn ↔ Output<String>
ARN of the Amplify app.
latefinal
autoBranchCreationConfig ↔ Output<AppAutoBranchCreationConfig>
Automated branch creation configuration for an Amplify app. See autoBranchCreationConfig Block for details.
latefinal
autoBranchCreationPatterns ↔ Output<List<String>?>
Automated branch creation glob patterns for an Amplify app.
latefinal
basicAuthCredentials ↔ Output<String?>
Credentials for basic authorization for an Amplify app.
latefinal
buildSpec ↔ Output<String>
The build specification (build spec) for an Amplify app.
latefinal
cacheConfig ↔ Output<AppCacheConfig>
Cache configuration for the Amplify app. See cacheConfig Block for details.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
computeRoleArn ↔ Output<String?>
AWS Identity and Access Management (IAM) SSR compute role for an Amplify app.
latefinal
customHeaders ↔ Output<String>
The custom HTTP headers for an Amplify app.
latefinal
customRules ↔ Output<List<AppCustomRule>?>
Custom rewrite and redirect rules for an Amplify app. See customRule Block for details.
latefinal
defaultDomain ↔ Output<String>
Default domain for the Amplify app.
latefinal
description ↔ Output<String?>
Description for an Amplify app.
latefinal
enableAutoBranchCreation ↔ Output<bool?>
Enables automated branch creation for an Amplify app.
latefinal
enableBasicAuth ↔ Output<bool?>
Enables basic authorization for an Amplify app. This will apply to all branches that are part of this app.
latefinal
enableBranchAutoBuild ↔ Output<bool?>
Enables auto-building of branches for the Amplify App.
latefinal
enableBranchAutoDeletion ↔ Output<bool?>
Automatically disconnects a branch in the Amplify Console when you delete a branch from your Git repository.
latefinal
environmentVariables ↔ Output<Map<String, String>?>
Environment variables map for an Amplify app.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
iamServiceRoleArn ↔ Output<String?>
AWS Identity and Access Management (IAM) service role for an Amplify app.
latefinal
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
jobConfig ↔ Output<AppJobConfig>
Used to configure the Amplify Application build instance compute type. See jobConfig Block for details.
latefinal
name ↔ Output<String>
Name for an Amplify app.
latefinal
oauthToken ↔ Output<String?>
OAuth token for a third-party source control system for an Amplify app. The OAuth token is used to create a webhook and a read-only deploy key. The OAuth token is not stored.
latefinal
platform ↔ Output<String?>
Platform or framework for an Amplify app. Valid values: WEB, WEB_COMPUTE. Default value: WEB.
latefinal
productionBranches ↔ Output<List<AppProductionBranch>>
Describes the information about a production branch for an Amplify app. A productionBranch block is documented below.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
repository ↔ Output<String?>
Repository for an Amplify app.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
tags ↔ Output<Map<String, String>?>
Key-value mapping of resource tags. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {AppState? state, CustomResourceOptions? options}) → App
Gets an existing App resource's state with the given name and id.