Pipeline

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.codestarconnections.Connection;
import com.pulumi.aws.codestarconnections.ConnectionArgs;
import com.pulumi.aws.s3.BucketV2;
import com.pulumi.aws.iam.IamFunctions;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
import com.pulumi.aws.iam.Role;
import com.pulumi.aws.iam.RoleArgs;
import com.pulumi.aws.kms.KmsFunctions;
import com.pulumi.aws.kms.inputs.GetAliasArgs;
import com.pulumi.aws.codepipeline.Pipeline;
import com.pulumi.aws.codepipeline.PipelineArgs;
import com.pulumi.aws.codepipeline.inputs.PipelineArtifactStoreArgs;
import com.pulumi.aws.codepipeline.inputs.PipelineArtifactStoreEncryptionKeyArgs;
import com.pulumi.aws.codepipeline.inputs.PipelineStageArgs;
import com.pulumi.aws.s3.BucketAclV2;
import com.pulumi.aws.s3.BucketAclV2Args;
import com.pulumi.aws.iam.RolePolicy;
import com.pulumi.aws.iam.RolePolicyArgs;
import java.util.List;
import java.util.ArrayList;
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 Connection("example", ConnectionArgs.builder()
            .providerType("GitHub")
            .build());
        var codepipelineBucket = new BucketV2("codepipelineBucket");
        final var assumeRole = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
            .statements(GetPolicyDocumentStatementArgs.builder()
                .effect("Allow")
                .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                    .type("Service")
                    .identifiers("codepipeline.amazonaws.com")
                    .build())
                .actions("sts:AssumeRole")
                .build())
            .build());
        var codepipelineRole = new Role("codepipelineRole", RoleArgs.builder()
            .assumeRolePolicy(assumeRole.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult.json()))
            .build());
        final var s3kmskey = KmsFunctions.getAlias(GetAliasArgs.builder()
            .name("alias/myKmsKey")
            .build());
        var codepipeline = new Pipeline("codepipeline", PipelineArgs.builder()
            .roleArn(codepipelineRole.arn())
            .artifactStores(PipelineArtifactStoreArgs.builder()
                .location(codepipelineBucket.bucket())
                .type("S3")
                .encryptionKey(PipelineArtifactStoreEncryptionKeyArgs.builder()
                    .id(s3kmskey.applyValue(getAliasResult -> getAliasResult.arn()))
                    .type("KMS")
                    .build())
                .build())
            .stages(
                PipelineStageArgs.builder()
                    .name("Source")
                    .actions(PipelineStageActionArgs.builder()
                        .name("Source")
                        .category("Source")
                        .owner("AWS")
                        .provider("CodeStarSourceConnection")
                        .version("1")
                        .outputArtifacts("source_output")
                        .configuration(Map.ofEntries(
                            Map.entry("ConnectionArn", example.arn()),
                            Map.entry("FullRepositoryId", "my-organization/example"),
                            Map.entry("BranchName", "main")
                        ))
                        .build())
                    .build(),
                PipelineStageArgs.builder()
                    .name("Build")
                    .actions(PipelineStageActionArgs.builder()
                        .name("Build")
                        .category("Build")
                        .owner("AWS")
                        .provider("CodeBuild")
                        .inputArtifacts("source_output")
                        .outputArtifacts("build_output")
                        .version("1")
                        .configuration(Map.of("ProjectName", "test"))
                        .build())
                    .build(),
                PipelineStageArgs.builder()
                    .name("Deploy")
                    .actions(PipelineStageActionArgs.builder()
                        .name("Deploy")
                        .category("Deploy")
                        .owner("AWS")
                        .provider("CloudFormation")
                        .inputArtifacts("build_output")
                        .version("1")
                        .configuration(Map.ofEntries(
                            Map.entry("ActionMode", "REPLACE_ON_FAILURE"),
                            Map.entry("Capabilities", "CAPABILITY_AUTO_EXPAND,CAPABILITY_IAM"),
                            Map.entry("OutputFileName", "CreateStackOutput.json"),
                            Map.entry("StackName", "MyStack"),
                            Map.entry("TemplatePath", "build_output::sam-templated.yaml")
                        ))
                        .build())
                    .build())
            .build());
        var codepipelineBucketAcl = new BucketAclV2("codepipelineBucketAcl", BucketAclV2Args.builder()
            .bucket(codepipelineBucket.id())
            .acl("private")
            .build());
        final var codepipelinePolicyPolicyDocument = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
            .statements(
                GetPolicyDocumentStatementArgs.builder()
                    .effect("Allow")
                    .actions(
                        "s3:GetObject",
                        "s3:GetObjectVersion",
                        "s3:GetBucketVersioning",
                        "s3:PutObjectAcl",
                        "s3:PutObject")
                    .resources(
                        codepipelineBucket.arn(),
                        codepipelineBucket.arn().applyValue(arn -> String.format("%s/*", arn)))
                    .build(),
                GetPolicyDocumentStatementArgs.builder()
                    .effect("Allow")
                    .actions("codestar-connections:UseConnection")
                    .resources(example.arn())
                    .build(),
                GetPolicyDocumentStatementArgs.builder()
                    .effect("Allow")
                    .actions(
                        "codebuild:BatchGetBuilds",
                        "codebuild:StartBuild")
                    .resources("*")
                    .build())
            .build());
        var codepipelinePolicyRolePolicy = new RolePolicy("codepipelinePolicyRolePolicy", RolePolicyArgs.builder()
            .role(codepipelineRole.id())
            .policy(codepipelinePolicyPolicyDocument.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult).applyValue(codepipelinePolicyPolicyDocument -> codepipelinePolicyPolicyDocument.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult.json())))
            .build());
    }
}

$ pulumi import aws:codepipeline/pipeline:Pipeline foo example