Branch class

Provides an Amplify Branch resource.

Example Usage

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

const example = new aws.amplify.App("example", {name: "app"});
const master = new aws.amplify.Branch("master", {
    appId: example.id,
    branchName: "master",
    framework: "React",
    stage: "PRODUCTION",
    environmentVariables: {
        REACT_APP_API_SERVER: "https://api.example.com",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.amplify.App("example", name="app")
master = aws.amplify.Branch("master",
    app_id=example.id,
    branch_name="master",
    framework="React",
    stage="PRODUCTION",
    environment_variables={
        "REACT_APP_API_SERVER": "https://api.example.com",
    })
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 = "app",
    });

    var master = new Aws.Amplify.Branch("master", new()
    {
        AppId = example.Id,
        BranchName = "master",
        Framework = "React",
        Stage = "PRODUCTION",
        EnvironmentVariables =
        {
            { "REACT_APP_API_SERVER", "https://api.example.com" },
        },
    });

});
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 {
		example, err := amplify.NewApp(ctx, "example", &amplify.AppArgs{
			Name: pulumi.String("app"),
		})
		if err != nil {
			return err
		}
		_, err = amplify.NewBranch(ctx, "master", &amplify.BranchArgs{
			AppId:      example.ID().ToIDOutput().ToStringOutput(),
			BranchName: pulumi.String("master"),
			Framework:  pulumi.String("React"),
			Stage:      pulumi.String("PRODUCTION"),
			EnvironmentVariables: pulumi.StringMap{
				"REACT_APP_API_SERVER": pulumi.String("https://api.example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_amplify_app" "example" {
  name = "app"
}
resource "aws_amplify_branch" "master" {
  app_id      = aws_amplify_app.example.id
  branch_name = "master"
  framework   = "React"
  stage       = "PRODUCTION"
  environment_variables = {
    "REACT_APP_API_SERVER" = "https://api.example.com"
  }
}
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.Branch;
import com.pulumi.aws.amplify.BranchArgs;
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("app")
            .build());

        var master = new Branch("master", BranchArgs.builder()
            .appId(example.id())
            .branchName("master")
            .framework("React")
            .stage("PRODUCTION")
            .environmentVariables(Map.of("REACT_APP_API_SERVER", "https://api.example.com"))
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      name: app
  master:
    type: aws:amplify:Branch
    properties:
      appId: ${example.id}
      branchName: master
      framework: React
      stage: PRODUCTION
      environmentVariables:
        REACT_APP_API_SERVER: https://api.example.com

Basic Authentication

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: "app"});
const master = new aws.amplify.Branch("master", {
    appId: example.id,
    branchName: "master",
    enableBasicAuth: true,
    basicAuthCredentials: std.base64encode({
        input: "username:password",
    }).then(invoke => invoke.result),
});
import pulumi
import pulumi_aws as aws
import pulumi_std as std

example = aws.amplify.App("example", name="app")
master = aws.amplify.Branch("master",
    app_id=example.id,
    branch_name="master",
    enable_basic_auth=True,
    basic_auth_credentials=std.base64encode(input="username:password").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 = "app",
    });

    var master = new Aws.Amplify.Branch("master", new()
    {
        AppId = example.Id,
        BranchName = "master",
        EnableBasicAuth = true,
        BasicAuthCredentials = Std.Base64encode.Invoke(new()
        {
            Input = "username:password",
        }).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 {
		example, err := amplify.NewApp(ctx, "example", &amplify.AppArgs{
			Name: pulumi.String("app"),
		})
		if err != nil {
			return err
		}
		invokeBase64encode, err := std.Base64encode(ctx, &std.Base64encodeArgs{
			Input: "username:password",
		}, nil)
		if err != nil {
			return err
		}
		_, err = amplify.NewBranch(ctx, "master", &amplify.BranchArgs{
			AppId:                example.ID().ToIDOutput().ToStringOutput(),
			BranchName:           pulumi.String("master"),
			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 = "app"
}
resource "aws_amplify_branch" "master" {
  app_id                 = aws_amplify_app.example.id
  branch_name            = "master"
  enable_basic_auth      = true
  basic_auth_credentials = base64encode("username:password")
}
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.Branch;
import com.pulumi.aws.amplify.BranchArgs;
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("app")
            .build());

        var master = new Branch("master", BranchArgs.builder()
            .appId(example.id())
            .branchName("master")
            .enableBasicAuth(true)
            .basicAuthCredentials(StdFunctions.base64encode(Base64encodeArgs.builder()
                .input("username:password")
                .build()).result())
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      name: app
  master:
    type: aws:amplify:Branch
    properties:
      appId: ${example.id}
      branchName: master
      enableBasicAuth: true
      basicAuthCredentials:
        fn::invoke:
          function: std:base64encode
          arguments:
            input: username:password
          return: result

Notifications

Amplify Console uses EventBridge (formerly known as CloudWatch Events) and SNS for email notifications. To implement the same functionality, you need to set enableNotification in a aws.amplify.Branch resource, as well as creating an EventBridge Rule, an SNS topic, and SNS subscriptions.

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

const example = new aws.amplify.App("example", {name: "app"});
const master = new aws.amplify.Branch("master", {
    appId: example.id,
    branchName: "master",
    enableNotification: true,
});
// EventBridge Rule for Amplify notifications
const amplifyAppMasterEventRule = new aws.cloudwatch.EventRule("amplify_app_master", {
    name: pulumi.interpolate`amplify-${app.id}-${master.branchName}-branch-notification`,
    description: pulumi.interpolate`AWS Amplify build notifications for :  App: ${app.id} Branch: ${master.branchName}`,
    eventPattern: pulumi.jsonStringify({
        detail: {
            appId: [example.id],
            branchName: [master.branchName],
            jobStatus: [
                "SUCCEED",
                "FAILED",
                "STARTED",
            ],
        },
        "detail-type": ["Amplify Deployment Status Change"],
        source: ["aws.amplify"],
    }),
});
// SNS Topic for Amplify notifications
const amplifyAppMasterTopic = new aws.sns.Topic("amplify_app_master", {name: pulumi.interpolate`amplify-${app.id}_${master.branchName}`});
const amplifyAppMasterEventTarget = new aws.cloudwatch.EventTarget("amplify_app_master", {
    inputTransformer: {
        inputPaths: {
            jobId: "$.detail.jobId",
            appId: "$.detail.appId",
            region: "$.region",
            branch: "$.detail.branchName",
            status: "$.detail.jobStatus",
        },
        inputTemplate: "\"Build notification from the AWS Amplify Console for app: https://<branch>.<appId>.amplifyapp.com/. Your build status is <status>. Go to https://console.aws.amazon.com/amplify/home?region=<region>#<appId>/<branch>/<jobId> to view details on your build. \"",
    },
    rule: amplifyAppMasterEventRule.name,
    targetId: master.branchName,
    arn: amplifyAppMasterTopic.arn,
});
const amplifyAppMaster = aws.iam.getPolicyDocumentOutput({
    statements: [{
        principals: [{
            type: "Service",
            identifiers: ["events.amazonaws.com"],
        }],
        sid: pulumi.interpolate`Allow_Publish_Events ${master.arn}`,
        effect: "Allow",
        actions: ["SNS:Publish"],
        resources: [amplifyAppMasterTopic.arn],
    }],
});
const amplifyAppMasterTopicPolicy = new aws.sns.TopicPolicy("amplify_app_master", {
    arn: amplifyAppMasterTopic.arn,
    policy: amplifyAppMaster.json,
});
const _this = new aws.sns.TopicSubscription("this", {
    topic: amplifyAppMasterTopic.arn,
    protocol: "email",
    endpoint: "user@acme.com",
});
import pulumi
import json
import pulumi_aws as aws

example = aws.amplify.App("example", name="app")
master = aws.amplify.Branch("master",
    app_id=example.id,
    branch_name="master",
    enable_notification=True)
# EventBridge Rule for Amplify notifications
amplify_app_master_event_rule = aws.cloudwatch.EventRule("amplify_app_master",
    name=master.branch_name.apply(lambda branch_name: f"amplify-{app['id']}-{branch_name}-branch-notification"),
    description=master.branch_name.apply(lambda branch_name: f"AWS Amplify build notifications for :  App: {app['id']} Branch: {branch_name}"),
    event_pattern=pulumi.Output.json_dumps({
        "detail": {
            "appId": [example.id],
            "branchName": [master.branch_name],
            "jobStatus": [
                "SUCCEED",
                "FAILED",
                "STARTED",
            ],
        },
        "detail-type": ["Amplify Deployment Status Change"],
        "source": ["aws.amplify"],
    }))
# SNS Topic for Amplify notifications
amplify_app_master_topic = aws.sns.Topic("amplify_app_master", name=master.branch_name.apply(lambda branch_name: f"amplify-{app['id']}_{branch_name}"))
amplify_app_master_event_target = aws.cloudwatch.EventTarget("amplify_app_master",
    input_transformer={
        "input_paths": {
            "jobId": "$.detail.jobId",
            "appId": "$.detail.appId",
            "region": "$.region",
            "branch": "$.detail.branchName",
            "status": "$.detail.jobStatus",
        },
        "input_template": "\"Build notification from the AWS Amplify Console for app: https://<branch>.<appId>.amplifyapp.com/. Your build status is <status>. Go to https://console.aws.amazon.com/amplify/home?region=<region>#<appId>/<branch>/<jobId> to view details on your build. \"",
    },
    rule=amplify_app_master_event_rule.name,
    target_id=master.branch_name,
    arn=amplify_app_master_topic.arn)
amplify_app_master = aws.iam.get_policy_document_output(statements=[{
    "principals": [{
        "type": "Service",
        "identifiers": ["events.amazonaws.com"],
    }],
    "sid": master.arn.apply(lambda arn: f"Allow_Publish_Events {arn}"),
    "effect": "Allow",
    "actions": ["SNS:Publish"],
    "resources": [amplify_app_master_topic.arn],
}])
amplify_app_master_topic_policy = aws.sns.TopicPolicy("amplify_app_master",
    arn=amplify_app_master_topic.arn,
    policy=amplify_app_master.json)
this = aws.sns.TopicSubscription("this",
    topic=amplify_app_master_topic.arn,
    protocol="email",
    endpoint="user@acme.com")
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amplify.App("example", new()
    {
        Name = "app",
    });

    var master = new Aws.Amplify.Branch("master", new()
    {
        AppId = example.Id,
        BranchName = "master",
        EnableNotification = true,
    });

    // EventBridge Rule for Amplify notifications
    var amplifyAppMasterEventRule = new Aws.CloudWatch.EventRule("amplify_app_master", new()
    {
        Name = master.BranchName.Apply(branchName => $"amplify-{app.Id}-{branchName}-branch-notification"),
        Description = master.BranchName.Apply(branchName => $"AWS Amplify build notifications for :  App: {app.Id} Branch: {branchName}"),
        EventPattern = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
        {
            ["detail"] = new Dictionary<string, object?>
            {
                ["appId"] = new[]
                {
                    example.Id,
                },
                ["branchName"] = new[]
                {
                    master.BranchName,
                },
                ["jobStatus"] = new[]
                {
                    "SUCCEED",
                    "FAILED",
                    "STARTED",
                },
            },
            ["detail-type"] = new[]
            {
                "Amplify Deployment Status Change",
            },
            ["source"] = new[]
            {
                "aws.amplify",
            },
        })),
    });

    // SNS Topic for Amplify notifications
    var amplifyAppMasterTopic = new Aws.Sns.Topic("amplify_app_master", new()
    {
        Name = master.BranchName.Apply(branchName => $"amplify-{app.Id}_{branchName}"),
    });

    var amplifyAppMasterEventTarget = new Aws.CloudWatch.EventTarget("amplify_app_master", new()
    {
        InputTransformer = new Aws.CloudWatch.Inputs.EventTargetInputTransformerArgs
        {
            InputPaths =
            {
                { "jobId", "$.detail.jobId" },
                { "appId", "$.detail.appId" },
                { "region", "$.region" },
                { "branch", "$.detail.branchName" },
                { "status", "$.detail.jobStatus" },
            },
            InputTemplate = "\"Build notification from the AWS Amplify Console for app: https://<branch>.<appId>.amplifyapp.com/. Your build status is <status>. Go to https://console.aws.amazon.com/amplify/home?region=<region>#<appId>/<branch>/<jobId> to view details on your build. \"",
        },
        Rule = amplifyAppMasterEventRule.Name,
        TargetId = master.BranchName,
        Arn = amplifyAppMasterTopic.Arn,
    });

    var amplifyAppMaster = Aws.Iam.GetPolicyDocument.Invoke(new()
    {
        Statements = new[]
        {
            new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
            {
                Principals = new[]
                {
                    new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
                    {
                        Type = "Service",
                        Identifiers = new[]
                        {
                            "events.amazonaws.com",
                        },
                    },
                },
                Sid = $"Allow_Publish_Events {master.Arn}",
                Effect = "Allow",
                Actions = new[]
                {
                    "SNS:Publish",
                },
                Resources = new[]
                {
                    amplifyAppMasterTopic.Arn,
                },
            },
        },
    });

    var amplifyAppMasterTopicPolicy = new Aws.Sns.TopicPolicy("amplify_app_master", new()
    {
        Arn = amplifyAppMasterTopic.Arn,
        Policy = amplifyAppMaster.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
    });

    var @this = new Aws.Sns.TopicSubscription("this", new()
    {
        Topic = amplifyAppMasterTopic.Arn,
        Protocol = "email",
        Endpoint = "user@acme.com",
    });

});
package main

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amplify"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := amplify.NewApp(ctx, "example", &amplify.AppArgs{
			Name: pulumi.String("app"),
		})
		if err != nil {
			return err
		}
		master, err := amplify.NewBranch(ctx, "master", &amplify.BranchArgs{
			AppId:              example.ID().ToIDOutput().ToStringOutput(),
			BranchName:         pulumi.String("master"),
			EnableNotification: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// EventBridge Rule for Amplify notifications
		amplifyAppMasterEventRule, err := cloudwatch.NewEventRule(ctx, "amplify_app_master", &cloudwatch.EventRuleArgs{
			Name: master.BranchName.ApplyT(func(branchName string) (string, error) {
				return fmt.Sprintf("amplify-%v-%v-branch-notification", app.Id, branchName), nil
			}).(pulumi.StringOutput),
			Description: master.BranchName.ApplyT(func(branchName string) (string, error) {
				return fmt.Sprintf("AWS Amplify build notifications for :  App: %v Branch: %v", app.Id, branchName), nil
			}).(pulumi.StringOutput),
			EventPattern: pulumi.All(example.ID(), master.BranchName).ApplyT(func(_args []interface{}) (string, error) {
				id := _args[0].(pulumi.ID)
				branchName := _args[1].(string)
				var _zero string
				tmpJSON0, err := json.Marshal(map[string]interface{}{
					"detail": map[string]interface{}{
						"appId": pulumi.IDArray{
							id,
						},
						"branchName": []string{
							branchName,
						},
						"jobStatus": []string{
							"SUCCEED",
							"FAILED",
							"STARTED",
						},
					},
					"detail-type": []string{
						"Amplify Deployment Status Change",
					},
					"source": []string{
						"aws.amplify",
					},
				})
				if err != nil {
					return _zero, err
				}
				json0 := string(tmpJSON0)
				return json0, nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		// SNS Topic for Amplify notifications
		amplifyAppMasterTopic, err := sns.NewTopic(ctx, "amplify_app_master", &sns.TopicArgs{
			Name: master.BranchName.ApplyT(func(branchName string) (string, error) {
				return fmt.Sprintf("amplify-%v_%v", app.Id, branchName), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = cloudwatch.NewEventTarget(ctx, "amplify_app_master", &cloudwatch.EventTargetArgs{
			InputTransformer: &cloudwatch.EventTargetInputTransformerArgs{
				InputPaths: pulumi.StringMap{
					"jobId":  pulumi.String("$.detail.jobId"),
					"appId":  pulumi.String("$.detail.appId"),
					"region": pulumi.String("$.region"),
					"branch": pulumi.String("$.detail.branchName"),
					"status": pulumi.String("$.detail.jobStatus"),
				},
				InputTemplate: pulumi.String("\"Build notification from the AWS Amplify Console for app: https://<branch>.<appId>.amplifyapp.com/. Your build status is <status>. Go to https://console.aws.amazon.com/amplify/home?region=<region>#<appId>/<branch>/<jobId> to view details on your build. \""),
			},
			Rule:     amplifyAppMasterEventRule.Name,
			TargetId: master.BranchName,
			Arn:      amplifyAppMasterTopic.Arn,
		})
		if err != nil {
			return err
		}
		amplifyAppMaster := iam.GetPolicyDocumentOutput(ctx, iam.GetPolicyDocumentOutputArgs{
			Statements: iam.GetPolicyDocumentStatementArray{
				&iam.GetPolicyDocumentStatementArgs{
					Principals: iam.GetPolicyDocumentStatementPrincipalArray{
						&iam.GetPolicyDocumentStatementPrincipalArgs{
							Type: pulumi.String("Service"),
							Identifiers: pulumi.StringArray{
								pulumi.String("events.amazonaws.com"),
							},
						},
					},
					Sid: master.Arn.ApplyT(func(arn string) (string, error) {
						return fmt.Sprintf("Allow_Publish_Events %v", arn), nil
					}).(pulumi.StringOutput),
					Effect: pulumi.String("Allow"),
					Actions: pulumi.StringArray{
						pulumi.String("SNS:Publish"),
					},
					Resources: pulumi.StringArray{
						amplifyAppMasterTopic.Arn,
					},
				},
			},
		}, nil)
		_, err = sns.NewTopicPolicy(ctx, "amplify_app_master", &sns.TopicPolicyArgs{
			Arn:    amplifyAppMasterTopic.Arn,
			Policy: amplifyAppMaster.Json(),
		})
		if err != nil {
			return err
		}
		_, err = sns.NewTopicSubscription(ctx, "this", &sns.TopicSubscriptionArgs{
			Topic:    amplifyAppMasterTopic.Arn,
			Protocol: pulumi.String("email"),
			Endpoint: pulumi.String("user@acme.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_iam_getpolicydocument" "amplifyAppMaster" {
  statements {
    principals {
      type        = "Service"
      identifiers = ["events.amazonaws.com"]
    }
    sid       ="Allow_Publish_Events ${aws_amplify_branch.master.arn}"
    effect    = "Allow"
    actions   = ["SNS:Publish"]
    resources = [aws_sns_topic.amplify_app_master.arn]
  }
}

resource "aws_amplify_app" "example" {
  name = "app"
}
resource "aws_amplify_branch" "master" {
  app_id              = aws_amplify_app.example.id
  branch_name         = "master"
  enable_notification = true
}
# EventBridge Rule for Amplify notifications
resource "aws_cloudwatch_eventrule" "amplify_app_master" {
  name        ="amplify-${app.id}-${aws_amplify_branch.master.branch_name}-branch-notification"
  description ="AWS Amplify build notifications for :  App: ${app.id} Branch: ${aws_amplify_branch.master.branch_name}"
  event_pattern = jsonencode({
    "detail" = {
      "appId"      = [aws_amplify_app.example.id]
      "branchName" = [aws_amplify_branch.master.branch_name]
      "jobStatus"  = ["SUCCEED", "FAILED", "STARTED"]
    }
    "detail-type" = ["Amplify Deployment Status Change"]
    "source"      = ["aws.amplify"]
  })
}
resource "aws_cloudwatch_eventtarget" "amplify_app_master" {
  input_transformer = {
    input_paths = {
      "jobId"  = "$.detail.jobId"
      "appId"  = "$.detail.appId"
      "region" = "$.region"
      "branch" = "$.detail.branchName"
      "status" = "$.detail.jobStatus"
    }
    input_template = "\"Build notification from the AWS Amplify Console for app: https://<branch>.<appId>.amplifyapp.com/. Your build status is <status>. Go to https://console.aws.amazon.com/amplify/home?region=<region>#<appId>/<branch>/<jobId> to view details on your build. \""
  }
  rule      = aws_cloudwatch_eventrule.amplify_app_master.name
  target_id = aws_amplify_branch.master.branch_name
  arn       = aws_sns_topic.amplify_app_master.arn
}
# SNS Topic for Amplify notifications
resource "aws_sns_topic" "amplify_app_master" {
  name ="amplify-${app.id}_${aws_amplify_branch.master.branch_name}"
}
resource "aws_sns_topicpolicy" "amplify_app_master" {
  arn    = aws_sns_topic.amplify_app_master.arn
  policy = data.aws_iam_getpolicydocument.amplifyAppMaster.json
}
resource "aws_sns_topicsubscription" "this" {
  topic    = aws_sns_topic.amplify_app_master.arn
  protocol = "email"
  endpoint = "user@acme.com"
}
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.Branch;
import com.pulumi.aws.amplify.BranchArgs;
import com.pulumi.aws.cloudwatch.EventRule;
import com.pulumi.aws.cloudwatch.EventRuleArgs;
import com.pulumi.aws.sns.Topic;
import com.pulumi.aws.sns.TopicArgs;
import com.pulumi.aws.cloudwatch.EventTarget;
import com.pulumi.aws.cloudwatch.EventTargetArgs;
import com.pulumi.aws.cloudwatch.inputs.EventTargetInputTransformerArgs;
import com.pulumi.aws.iam.IamFunctions;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementArgs;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementPrincipalArgs;
import com.pulumi.aws.sns.TopicPolicy;
import com.pulumi.aws.sns.TopicPolicyArgs;
import com.pulumi.aws.sns.TopicSubscription;
import com.pulumi.aws.sns.TopicSubscriptionArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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("app")
            .build());

        var master = new Branch("master", BranchArgs.builder()
            .appId(example.id())
            .branchName("master")
            .enableNotification(true)
            .build());

        // EventBridge Rule for Amplify notifications
        var amplifyAppMasterEventRule = new EventRule("amplifyAppMasterEventRule", EventRuleArgs.builder()
            .name(master.branchName().applyValue(_branchName -> String.format("amplify-%s-%s-branch-notification", app.id(),_branchName)))
            .description(master.branchName().applyValue(_branchName -> String.format("AWS Amplify build notifications for :  App: %s Branch: %s", app.id(),_branchName)))
            .eventPattern(Output.tuple(example.id(), master.branchName()).applyValue(values -> {
                var id = values.t1;
                var branchName = values.t2;
                return serializeJson(
                    jsonObject(
                        jsonProperty("detail", jsonObject(
                            jsonProperty("appId", jsonArray(id)),
                            jsonProperty("branchName", jsonArray(branchName)),
                            jsonProperty("jobStatus", jsonArray(
                                "SUCCEED",
                                "FAILED",
                                "STARTED"
                            ))
                        )),
                        jsonProperty("detail-type", jsonArray("Amplify Deployment Status Change")),
                        jsonProperty("source", jsonArray("aws.amplify"))
                    ));
            }))
            .build());

        // SNS Topic for Amplify notifications
        var amplifyAppMasterTopic = new Topic("amplifyAppMasterTopic", TopicArgs.builder()
            .name(master.branchName().applyValue(_branchName -> String.format("amplify-%s_%s", app.id(),_branchName)))
            .build());

        var amplifyAppMasterEventTarget = new EventTarget("amplifyAppMasterEventTarget", EventTargetArgs.builder()
            .inputTransformer(EventTargetInputTransformerArgs.builder()
                .inputPaths(Map.ofEntries(
                    Map.entry("jobId", "$.detail.jobId"),
                    Map.entry("appId", "$.detail.appId"),
                    Map.entry("region", "$.region"),
                    Map.entry("branch", "$.detail.branchName"),
                    Map.entry("status", "$.detail.jobStatus")
                ))
                .inputTemplate("\"Build notification from the AWS Amplify Console for app: https://<branch>.<appId>.amplifyapp.com/. Your build status is <status>. Go to https://console.aws.amazon.com/amplify/home?region=<region>#<appId>/<branch>/<jobId> to view details on your build. \"")
                .build())
            .rule(amplifyAppMasterEventRule.name())
            .targetId(master.branchName())
            .arn(amplifyAppMasterTopic.arn())
            .build());

        final var amplifyAppMaster = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
            .statements(GetPolicyDocumentStatementArgs.builder()
                .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                    .type("Service")
                    .identifiers("events.amazonaws.com")
                    .build())
                .sid(master.arn().applyValue(_arn -> String.format("Allow_Publish_Events %s", _arn)))
                .effect("Allow")
                .actions("SNS:Publish")
                .resources(amplifyAppMasterTopic.arn())
                .build())
            .build());

        var amplifyAppMasterTopicPolicy = new TopicPolicy("amplifyAppMasterTopicPolicy", TopicPolicyArgs.builder()
            .arn(amplifyAppMasterTopic.arn())
            .policy(amplifyAppMaster.applyValue(_amplifyAppMaster -> _amplifyAppMaster.json()))
            .build());

        var this_ = new TopicSubscription("this", TopicSubscriptionArgs.builder()
            .topic(amplifyAppMasterTopic.arn())
            .protocol("email")
            .endpoint("user@acme.com")
            .build());

    }
}
resources:
  example:
    type: aws:amplify:App
    properties:
      name: app
  master:
    type: aws:amplify:Branch
    properties:
      appId: ${example.id}
      branchName: master
      enableNotification: true
  # EventBridge Rule for Amplify notifications
  amplifyAppMasterEventRule:
    type: aws:cloudwatch:EventRule
    name: amplify_app_master
    properties:
      name: amplify-${app.id}-${master.branchName}-branch-notification
      description: 'AWS Amplify build notifications for :  App: ${app.id} Branch: ${master.branchName}'
      eventPattern:
        fn::toJSON:
          detail:
            appId:
              - ${example.id}
            branchName:
              - ${master.branchName}
            jobStatus:
              - SUCCEED
              - FAILED
              - STARTED
          detail-type:
            - Amplify Deployment Status Change
          source:
            - aws.amplify
  amplifyAppMasterEventTarget:
    type: aws:cloudwatch:EventTarget
    name: amplify_app_master
    properties:
      inputTransformer:
        inputPaths:
          jobId: $.detail.jobId
          appId: $.detail.appId
          region: $.region
          branch: $.detail.branchName
          status: $.detail.jobStatus
        inputTemplate: '"Build notification from the AWS Amplify Console for app: https://<branch>.<appId>.amplifyapp.com/. Your build status is <status>. Go to https://console.aws.amazon.com/amplify/home?region=<region>#<appId>/<branch>/<jobId> to view details on your build. "'
      rule: ${amplifyAppMasterEventRule.name}
      targetId: ${master.branchName}
      arn: ${amplifyAppMasterTopic.arn}
  # SNS Topic for Amplify notifications
  amplifyAppMasterTopic:
    type: aws:sns:Topic
    name: amplify_app_master
    properties:
      name: amplify-${app.id}_${master.branchName}
  amplifyAppMasterTopicPolicy:
    type: aws:sns:TopicPolicy
    name: amplify_app_master
    properties:
      arn: ${amplifyAppMasterTopic.arn}
      policy: ${amplifyAppMaster.json}
  this:
    type: aws:sns:TopicSubscription
    properties:
      topic: ${amplifyAppMasterTopic.arn}
      protocol: email
      endpoint: user@acme.com
variables:
  amplifyAppMaster:
    fn::invoke:
      function: aws:iam:getPolicyDocument
      arguments:
        statements:
          - principals:
              - type: Service
                identifiers:
                  - events.amazonaws.com
            sid: Allow_Publish_Events ${master.arn}
            effect: Allow
            actions:
              - SNS:Publish
            resources:
              - ${amplifyAppMasterTopic.arn}

Import

Using pulumi import, import Amplify branch using appId and branchName. For example:

$ pulumi import aws:amplify/branch:Branch master d2ypk4k47z8u6/master

Constructors

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

Properties

appId ↔ Output<String>
Unique ID for an Amplify app.
latefinal
arn ↔ Output<String>
ARN for the branch.
latefinal
associatedResources ↔ Output<List<String>>
A list of custom resources that are linked to this branch.
latefinal
backendEnvironmentArn ↔ Output<String?>
ARN for a backend environment that is part of an Amplify app.
latefinal
basicAuthCredentials ↔ Output<String?>
Basic authorization credentials for the branch.
latefinal
branchName ↔ Output<String>
Name for the branch.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
customDomains ↔ Output<List<String>>
Custom domains for the branch.
latefinal
description ↔ Output<String?>
Description for the branch.
latefinal
destinationBranch ↔ Output<String>
Destination branch if the branch is a pull request branch.
latefinal
displayName ↔ Output<String>
Display name for a branch. This is used as the default domain prefix.
latefinal
enableAutoBuild ↔ Output<bool?>
Enables auto building for the branch.
latefinal
enableBasicAuth ↔ Output<bool?>
Enables basic authorization for the branch.
latefinal
enableNotification ↔ Output<bool?>
Enables notifications for the branch.
latefinal
enablePerformanceMode ↔ Output<bool?>
Enables performance mode for the branch.
latefinal
enablePullRequestPreview ↔ Output<bool?>
Enables pull request previews for this branch.
latefinal
enableSkewProtection ↔ Output<bool?>
Enables skew protection for the branch.
latefinal
environmentVariables ↔ Output<Map<String, String>?>
Environment variables for the branch.
latefinal
framework ↔ Output<String?>
Framework for the branch.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
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
pullRequestEnvironmentName ↔ Output<String?>
Amplify environment name for the pull request.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
sourceBranch ↔ Output<String>
Source branch if the branch is a pull request branch.
latefinal
stage ↔ Output<String?>
Describes the current stage for the branch. Valid values: PRODUCTION, BETA, DEVELOPMENT, EXPERIMENTAL, PULL_REQUEST.
latefinal
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
ttl ↔ Output<String?>
Content Time To Live (TTL) for the website in seconds.
latefinal
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, {BranchState? state, CustomResourceOptions? options}) → Branch
Gets an existing Branch resource's state with the given name and id.