internal CdkPipelineStack(Construct scope, string id, CdkPipelineStackProps props = null) : base(scope, id, props)
{
var sourceArtifact = new Artifact_("SourceArtifact");
var outputArtifact = new Artifact_("OutputArtifact");
var sourceAction = new CodeCommitSourceAction(new CodeCommitSourceActionProps
{
ActionName = "CodeCommit",
Output = sourceArtifact,
Repository = props.MyRepository,
Branch = "main",
});
// Self mutation
var pipeline = new CdkPipeline(this, "CdkPipeline", new CdkPipelineProps
{
PipelineName = "CrossAccountSourcePipeline",
CloudAssemblyArtifact = outputArtifact,
SourceAction = sourceAction,
// It synthesizes CDK code to cdk.out directory which is picked by SelfMutate stage to mutate the pipeline
SynthAction = new SimpleSynthAction(new SimpleSynthActionProps
{
SourceArtifact = sourceArtifact,
CloudAssemblyArtifact = outputArtifact,
InstallCommands = new[]
{
"npm install -g aws-cdk",
},
BuildCommands = new[] { "dotnet build" },
SynthCommand = "cdk synth",
}),
});
}
private void GetS3ActionResources(PipelineActionS3Options actionS3Options, IDictionary <string, Artifact_> artifacts, out IBucket bucket, out Artifact_ artifact, out IRole role)
{
// Locate bucket
bucket = LocateBucket(actionS3Options.BucketName,
$"The bucket {actionS3Options.BucketName} of the pipeline action {actionS3Options.Name} was not found",
$"The pipeline action {actionS3Options.Name} must have a bucket");
// Create artifact
if (string.IsNullOrWhiteSpace(actionS3Options.OutputArtifact))
{
throw new ArgumentException($"There is no output artifact in the pipeline action {actionS3Options.Name}");
}
else
{
if (artifacts.ContainsKey(actionS3Options.OutputArtifact))
{
throw new ArgumentException($"The artifact {actionS3Options.OutputArtifact} of the pipeline action {actionS3Options.Name} already exists");
}
else
{
artifact = new Artifact_();
artifacts.Add(actionS3Options.OutputArtifact, artifact);
}
}
// Locate role
role = LocateRole(actionS3Options.Role, $"The role {actionS3Options.Role} of the pipeline action {actionS3Options.Name} was not found");
}
public WorkshopPipelineStack(Constructs.Construct scope = null, string id = null, IStackProps props = null) : base(scope, id, props)
{
var repo = new Repository(this, "WorkshopRepo", new RepositoryProps {
RepositoryName = "WorkshopRepo"
});
var sourceArtifact = new Artifact_();
var cloudAssemblyArtifact = new Artifact_();
var pipeline = new CdkPipeline(this, "Pipeline", new CdkPipelineProps {
PipelineName = "WorkshopPipeline",
CloudAssemblyArtifact = cloudAssemblyArtifact,
SourceAction = new CodeCommitSourceAction(new CodeCommitSourceActionProps {
ActionName = "CodeCommit",
Output = sourceArtifact,
Repository = repo
}),
SynthAction = SimpleSynthAction.StandardNpmSynth(new StandardNpmSynthOptions {
SourceArtifact = sourceArtifact,
CloudAssemblyArtifact = cloudAssemblyArtifact,
InstallCommand = "npm install -g aws-cdk"
+ " && wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb"
+ " && dpkg -i packages-microsoft-prod.deb"
+ " && apt-get update"
+ " && apt-get install -y dotnet-sdk-3.1",
BuildCommand = "dotnet build src"
})
});
var deploy = new WorkshopPipelineStage(this, "Deploy");
var deployStage = pipeline.AddApplicationStage(deploy);
}
private void GetCodeBuildActionResources(PipelineActionCodeBuildOptions actionCodeBuildOptions, IDictionary <string, Artifact_> artifacts, out Artifact_ inputArtifact, out Artifact_ outputArtifact, out IProject project)
{
// Locate artifact
if (string.IsNullOrWhiteSpace(actionCodeBuildOptions.InputArtifact))
{
throw new ArgumentException($"There is no input artifact in the pipeline action {actionCodeBuildOptions.Name}");
}
else
{
if (!artifacts.TryGetValue(actionCodeBuildOptions.InputArtifact, out inputArtifact))
{
throw new ArgumentException($"The artifact {actionCodeBuildOptions.InputArtifact} of the pipeline action {actionCodeBuildOptions.Name} was not found");
}
}
if (!string.IsNullOrEmpty(actionCodeBuildOptions.OutputArtifact))
{
if (artifacts.ContainsKey(actionCodeBuildOptions.OutputArtifact))
{
throw new ArgumentException($"The artifact {actionCodeBuildOptions.OutputArtifact} of the pipeline action {actionCodeBuildOptions.Name} already exists");
}
else
{
outputArtifact = new Artifact_(actionCodeBuildOptions.OutputArtifact);
artifacts.Add(actionCodeBuildOptions.OutputArtifact, outputArtifact);
}
}
else
{
// We don't have an output artifact specified
outputArtifact = null;
}
// Locate CodeBuild project
project = LocateCodeBuildProject(actionCodeBuildOptions.CodeBuildProject, $"The CodeBuild project {actionCodeBuildOptions.CodeBuildProject} of the pipeline action {actionCodeBuildOptions.Name} was not found");
}
private void GetEcrActionResources(PipelineActionEcrOptions actionEcrOptions, IDictionary <string, Artifact_> artifacts, out IRepository ecrRepository, out Artifact_ artifact, out IRole role)
{
ecrRepository = LocateEcrRepository(actionEcrOptions.EcrRepositoryName,
$"The ECR Repository {actionEcrOptions.EcrRepositoryName} of the pipeline action {actionEcrOptions.Name} was not found",
$"The pipeline action {actionEcrOptions.Name} must have a ECR Repository");
// Create artifact
if (string.IsNullOrWhiteSpace(actionEcrOptions.OutputArtifact))
{
throw new ArgumentException($"There is no output artifact in the pipeline action {actionEcrOptions.Name}");
}
else
{
if (artifacts.ContainsKey(actionEcrOptions.OutputArtifact))
{
throw new ArgumentException($"The artifact {actionEcrOptions.OutputArtifact} of the pipeline action {actionEcrOptions.Name} already exists");
}
else
{
artifact = new Artifact_(actionEcrOptions.OutputArtifact);
artifacts.Add(actionEcrOptions.OutputArtifact, artifact);
}
}
// Locate role
role = LocateRole(actionEcrOptions.Role, $"The role {actionEcrOptions.Role} of the pipeline action {actionEcrOptions.Name} was not found");
}
public PipelineStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
var sourceArtifact = new Artifact_();
var cloudAssemblyArtifact = new Artifact_();
var pipeline = new CdkPipeline(this, "CdkPipeline", new CdkPipelineProps
{
PipelineName = "sandbank-api-pipeline",
CdkCliVersion = "1.63.0",
SourceAction = new GitHubSourceAction(new GitHubSourceActionProps
{
ActionName = "synth-cdk",
Owner = "nicostouch",
Repo = "sandbank",
Output = sourceArtifact,
OauthToken = SecretValue.SecretsManager("github/oauth/token")
}),
SynthAction = new SimpleSynthAction(new SimpleSynthActionProps
{
SynthCommand = "cdk synth",
Subdirectory = "DevOps/Infrastructure/CDK",
SourceArtifact = sourceArtifact,
CloudAssemblyArtifact = cloudAssemblyArtifact
}),
CloudAssemblyArtifact = cloudAssemblyArtifact
});
}
private void CreatePipeline(IRole cloudFormationRole, PipelineProject build, string githubOwner, string githubRepository, string githubOauthToken, string gitBranch)
{
Console.WriteLine($"... defining {gitBranch} pipeline");
var buildOutput = new Artifact_("BuildOutput");
new Pipeline(this, "Pipeline-" + gitBranch, new PipelineProps
{
Stages = new StageProps[]
{
new StageProps
{
StageName = "Source",
Actions = new IAction[]
{
new GitHubSourceAction(new GitHubSourceActionProps
{
ActionName = "GitHubSource",
Branch = gitBranch,
Repo = githubRepository,
Owner = githubOwner,
OauthToken = SecretValue.PlainText(githubOauthToken),
Output = SourceOutput
})
}
},
new StageProps
{
StageName = "Build",
Actions = new IAction[]
{
new CodeBuildAction(new CodeBuildActionProps
{
ActionName = $"Build-{gitBranch}",
Project = build,
Input = SourceOutput,
Outputs = new Artifact_[] { buildOutput }
})
}
},
new StageProps
{
StageName = "Deploy",
Actions = new IAction[]
{
new CloudFormationCreateUpdateStackAction(new CloudFormationCreateUpdateStackActionProps
{
ActionName = "DeployServerlessTemplate",
Capabilities = new CloudFormationCapabilities[] { CloudFormationCapabilities.ANONYMOUS_IAM, CloudFormationCapabilities.AUTO_EXPAND },
TemplatePath = ArtifactPath_.ArtifactPath(buildOutput.ArtifactName, "updated.template"),
StackName = $"{githubRepository}-{gitBranch}-{DateTime.Now.Ticks}",
AdminPermissions = true
})
}
}
}
});
}
public CodeBuildAction CreateCodeBuildAction(string actionName, Artifact_ inputArtifact, Artifact_ outputArtifact, IProject codeBuildProject, Dictionary <string, IBuildEnvironmentVariable> environmentVariables)
{
return(new CodeBuildAction(new CodeBuildActionProps
{
ActionName = actionName,
Input = inputArtifact,
Outputs = outputArtifact != null ? new[] { outputArtifact } : null,
Project = codeBuildProject,
EnvironmentVariables = environmentVariables
}));
}
public EcrSourceAction CreateEcrAction(string actionName, string imageTag, Artifact_ outputArtifact, IRepository repositoryInstance, IRole role = null, string variableNamespace = null, double?runOrder = null)
{
return(new EcrSourceAction(new EcrSourceActionProps
{
ActionName = actionName,
ImageTag = imageTag,
Output = outputArtifact,
Repository = repositoryInstance,
Role = role,
RunOrder = runOrder,
VariablesNamespace = variableNamespace
}));
}
internal PipelineStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
Artifact_ sourceArtifact = new Artifact_();
Artifact_ cloudAssemblyArtifact = new Artifact_();
CdkPipeline pipeline = new CdkPipeline(this, "LambdaApiSolutionPipeline", new CdkPipelineProps()
{
CloudAssemblyArtifact = cloudAssemblyArtifact,
PipelineName = "LambdaApiSolutionPipeline",
SourceAction = new GitHubSourceAction(new GitHubSourceActionProps()
{
ActionName = "GitHubSource",
Output = sourceArtifact,
OauthToken = SecretValue.SecretsManager(Constants.GitHubTokenSecretsManagerId),
Owner = Constants.Owner,
Repo = Constants.RepositoryName,
Branch = Constants.Branch,
Trigger = GitHubTrigger.POLL
}),
SynthAction = new SimpleSynthAction(new SimpleSynthActionProps()
{
Environment = new BuildEnvironment
{
// required for .NET 5
// https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html
BuildImage = LinuxBuildImage.STANDARD_5_0
},
SourceArtifact = sourceArtifact,
CloudAssemblyArtifact = cloudAssemblyArtifact,
Subdirectory = "LambdaApiSolution",
InstallCommands = new[] { "npm install -g aws-cdk" },
BuildCommands = new[] { "dotnet build src/LambdaApiSolution.sln" },
SynthCommand = "cdk synth"
})
});
CdkStage developmentStage = pipeline.AddApplicationStage(new SolutionStage(this, "Development"));
CdkStage testStage = pipeline.AddApplicationStage(new SolutionStage(this, "Test"));
testStage.AddManualApprovalAction(new AddManualApprovalOptions()
{
ActionName = "PromoteToProduction"
});
CdkStage productionStage = pipeline.AddApplicationStage(new SolutionStage(this, "Production"));
}
public IStage CreateCodeBuildActionInStage(IStage stage, string actionName, Artifact_ inputArtifact, Artifact_ outputArtifact, IProject codeBuildProject, Dictionary <string, string> environmentVariables)
{
var environmentVariablesPlain = new Dictionary <string, IBuildEnvironmentVariable>();
if (environmentVariables != null)
{
foreach (var keyValue in environmentVariables)
{
environmentVariablesPlain.Add(keyValue.Key, new BuildEnvironmentVariable
{
Type = BuildEnvironmentVariableType.PLAINTEXT,
Value = keyValue.Value
});
}
}
var action = HandlerResources.AwsCdkPipelineHandler.CreateCodeBuildAction(actionName, inputArtifact, outputArtifact, codeBuildProject, environmentVariablesPlain);
stage.AddAction(action);
return(stage);
}
private Pipeline CreateCiCdPipeline(Repository dockerRepo, Vcs.Repository gitRepo)
{
Artifact_ sourceCodeArtifact = new Artifact_("Unicorn-Store-Visual-Studio-Solution");
var buildPipeline = new Pipeline(this, "BuildPipeline",
new PipelineProps
{
PipelineName = this.settings.ScopeName,
Stages = new[]
{
Helpers.StageFromActions("Source", CreateSourceVcsCheckoutAction(gitRepo, sourceCodeArtifact)),
Helpers.StageFromActions("Build",
this.CreateDockerImageBuildAction(dockerRepo, sourceCodeArtifact),
this.CreateAppDeploymentEnvironmentBuildAction(sourceCodeArtifact)
),
Helpers.StageFromActions("Restart-the-App", this.CreateLambdaInvokeAction())
}
}
);;
return(buildPipeline);
}
internal AppdeploymentStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
#region Application hosting resources
var vpc = new Vpc(this, "appVpc", new VpcProps
{
MaxAzs = 3
});
var image = new LookupMachineImage(new LookupMachineImageProps
{
// maps to "Amazon Linux 2 with .NET Core 3.0 and Mono 5.18"
Name = "amzn2-ami-hvm-2.0.*-x86_64-gp2-mono-*",
Owners = new [] { "amazon" }
});
var userData = UserData.ForLinux();
userData.AddCommands(new string[]
{
"sudo yum install -y httpd",
"sudo systemctl start httpd",
"sudo systemctl enable httpd"
});
var scalingGroup = new AutoScalingGroup(this, "appASG", new AutoScalingGroupProps
{
Vpc = vpc,
InstanceType = InstanceType.Of(InstanceClass.BURSTABLE3, InstanceSize.MEDIUM),
MachineImage = image,
MinCapacity = 1,
MaxCapacity = 4,
AllowAllOutbound = true,
UserData = userData
});
var alb = new ApplicationLoadBalancer(this, "appLB", new ApplicationLoadBalancerProps
{
Vpc = vpc,
InternetFacing = true
});
var albListener = alb.AddListener("Port80Listener", new BaseApplicationListenerProps
{
Port = 80
});
albListener.AddTargets("Port80ListenerTargets", new AddApplicationTargetsProps
{
Port = 80,
Targets = new [] { scalingGroup }
});
albListener.Connections.AllowDefaultPortFromAnyIpv4("Open access to port 80");
scalingGroup.ScaleOnRequestCount("ScaleOnModestLoad", new RequestCountScalingProps
{
TargetRequestsPerSecond = 1
});
#endregion
#region CI/CD resources
var _sourceOutput = new Artifact_("Source");
var _buildOutput = new Artifact_("Build");
var build = new PipelineProject(this, "CodeBuild", new PipelineProjectProps
{
// relative path to sample app's file (single html page for now)
BuildSpec = BuildSpec.FromSourceFilename("talk-demos/appdeployment/SimplePage/buildspec.yml"),
Environment = new BuildEnvironment
{
BuildImage = LinuxBuildImage.AMAZON_LINUX_2_2
},
});
var appDeployment = new ServerApplication(this, "appDeployment");
// we will use CodeDeploy's default one-at-a-time deployment mode as we are
// not specifying a deployment config
var deploymentGroup = new ServerDeploymentGroup(this, "appDeploymentGroup", new ServerDeploymentGroupProps
{
Application = appDeployment,
InstallAgent = true,
AutoRollback = new AutoRollbackConfig
{
FailedDeployment = true
},
AutoScalingGroups = new [] { scalingGroup }
});
// SecretValue.SsmSecure is not currently supported for setting OauthToken,
// and haven't gotten the SecretsManager approach to work either so
// resorting to keeping my token in an environment var for now!
var oauthToken = SecretValue.PlainText(System.Environment.GetEnvironmentVariable("GitHubPersonalToken"));
var pipeline = new Pipeline(this, "sampleappPipeline", new PipelineProps
{
Stages = new StageProps[]
{
new StageProps
{
StageName = "Source",
Actions = new IAction[]
{
new GitHubSourceAction(new GitHubSourceActionProps
{
ActionName = "GitHubSource",
Branch = "master",
Repo = this.Node.TryGetContext("repo-name").ToString(),
Owner = this.Node.TryGetContext("repo-owner").ToString(),
OauthToken = oauthToken,
Output = _sourceOutput
})
}
},
new StageProps
{
StageName = "Build",
Actions = new IAction[]
{
new CodeBuildAction(new CodeBuildActionProps
{
ActionName = "Build-app",
Project = build,
Input = _sourceOutput,
Outputs = new Artifact_[] { _buildOutput },
RunOrder = 1
})
}
},
new StageProps
{
StageName = "Deploy",
Actions = new IAction[]
{
new CodeDeployServerDeployAction(new CodeDeployServerDeployActionProps
{
ActionName = "Deploy-app",
Input = _buildOutput,
RunOrder = 2,
DeploymentGroup = deploymentGroup
})
}
}
}
});
#endregion
}
internal PipelineStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
var stackProps = props as PipelineStackProps;
var codestarArn = $"arn:aws:codestar-connections:us-east-1:{this.Account}:connection/{stackProps.CodeStarConnectionId}";
var encryptionKey = Key.FromKeyArn(this, "encryptionKey", $"arn:aws:kms:{this.Region}:{this.Account}:key/{stackProps.KMSKeyId}");
var sourceArtifact = Bucket.FromBucketAttributes(this, "sourceArtifact", new BucketAttributes
{
BucketArn = $"arn:aws:s3:::codepipeline-artifacts-{this.Account}-{this.Region}",
EncryptionKey = encryptionKey
});
var pipelineRole = Role.FromRoleArn(this, "pipelineRole",
$"arn:aws:iam::{this.Account}:role/CodePipelineMasterRole",
new FromRoleArnOptions {
Mutable = false
}
);
var sourceOutputArtifact = new Artifact_();
var cdkBuildOutput = new Artifact_("CdkBuildOutput");
var apiName = new CfnParameter(this, "ApiName", new CfnParameterProps
{
Type = "String",
Description = "The name of the API"
});
var apiNameLower = new CfnParameter(this, "ApiNameLower", new CfnParameterProps
{
Type = "String",
Description = "The name of the API in Lowercase"
});
//
// Create the pipeline
//
var pipeline = new Pipeline(this, $"ApiPipeline", new PipelineProps
{
PipelineName = $"{apiName.ValueAsString}ApiPipeline",
ArtifactBucket = sourceArtifact,
Role = pipelineRole,
Stages = new[]
{
new Amazon.CDK.AWS.CodePipeline.StageProps {
StageName = "Source",
Actions = new []
{
new CodeStarConnectionsSourceAction(new CodeStarConnectionsSourceActionProps
{
ActionName = "Github",
Branch = "main",
Output = sourceOutputArtifact,
Owner = "kumaranbsundar",
Repo = stackProps.RepoName,
TriggerOnPush = true,
ConnectionArn = codestarArn,
Role = pipelineRole,
VariablesNamespace = "SourceVariables"
})
}
},
new Amazon.CDK.AWS.CodePipeline.StageProps {
StageName = "Build",
Actions = new []
{
new CodeBuildAction(new CodeBuildActionProps {
ActionName = "CDK_Synth",
Project = GetCdkBuildProject(encryptionKey, pipelineRole),
Input = sourceOutputArtifact,
Outputs = new[] { cdkBuildOutput },
Role = pipelineRole,
EnvironmentVariables = new Dictionary <string, IBuildEnvironmentVariable> {
{
"API_NAME", new BuildEnvironmentVariable {
Type = BuildEnvironmentVariableType.PLAINTEXT,
Value = apiNameLower.ValueAsString
}
}
}
})
}
}
}
});
stackProps.DeployEnvs.ToList().ForEach(de =>
{
var crossAccountRole = Role.FromRoleArn(this, "crossAccountRole",
$"arn:aws:iam::{de.AccountId}:role/CodePipelineCrossAccountRole",
new FromRoleArnOptions {
Mutable = false
}
);
var deploymentRole = Role.FromRoleArn(this, "deploymentRole",
$"arn:aws:iam::{de.AccountId}:role/CodePipelineCfnDeploymentRole",
new FromRoleArnOptions {
Mutable = false
}
);
pipeline.AddStage(GetPipelineStage(
de,
apiNameLower.ValueAsString,
cdkBuildOutput,
crossAccountRole,
deploymentRole,
pipelineRole,
sourceOutputArtifact,
GetContainerBuildProject(encryptionKey, pipelineRole)
));
});
}
internal DotnetPipelineStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
string REPO_NAME = "dotnet-pipeline";
string STACK_NAME = "DotnetFunctionalStack";
var code = Repository.FromRepositoryName(this, "ImportedRepo", REPO_NAME);
var sourceOutput = new Artifact_();
var cdkDeploy = new PipelineProject(this, "CDKDeploy", new PipelineProjectProps
{
BuildSpec = BuildSpec.FromObject(new Dictionary <string, object> {
["version"] = "0.2",
["phases"] = new Dictionary <string, object>
{
["install"] = new Dictionary <string, string>
{
["commands"] = "npm install -g aws-cdk"
},
["build"] = new Dictionary <string, object>
{
["commands"] = new [] { "src/scripts/build.sh", "cdk deploy " + STACK_NAME }
}
}
}),
Environment = new BuildEnvironment {
BuildImage = LinuxBuildImage.AMAZON_LINUX_2_3
}
});
var statement = new Amazon.CDK.AWS.IAM.PolicyStatement();
statement.Effect = Effect.ALLOW;
statement.AddActions(new [] { "*" });
statement.AddAllResources();
cdkDeploy.Role.AddToPolicy(statement);
var pipeline = new Amazon.CDK.AWS.CodePipeline.Pipeline(this, "Pipeline", new PipelineProps {
Stages = new [] {
new StageProps
{
StageName = "Source",
Actions = new []
{
new CodeCommitSourceAction(new CodeCommitSourceActionProps
{
ActionName = "Source",
Repository = code,
Output = sourceOutput
})
}
},
new StageProps
{
StageName = "Deploy",
Actions = new []
{
new CodeBuildAction(new CodeBuildActionProps
{
ActionName = "CDK_Deploy",
Project = cdkDeploy,
Input = sourceOutput
})
}
}
}
});
}
private void GetCloudFormationActionResources(PipelineActionCloudFormationOptions actionCloudFormationOptions, IDictionary <string, Artifact_> artifacts, out Artifact_ artifact, out IRole deploymentRole, out IRole role, out CfnCapabilities[] cfnCapabilities)
{
// Locate artifact
if (string.IsNullOrWhiteSpace(actionCloudFormationOptions.InputArtifact))
{
throw new ArgumentException($"There is no input artifact in the pipeline action {actionCloudFormationOptions.Name}");
}
else
{
if (!artifacts.TryGetValue(actionCloudFormationOptions.InputArtifact, out artifact))
{
throw new ArgumentException($"The artifact {actionCloudFormationOptions.InputArtifact} of the pipeline action {actionCloudFormationOptions.Name} was not found");
}
}
// Locate deployment role
deploymentRole = LocateRole(actionCloudFormationOptions.DeploymentRole,
$"The role {actionCloudFormationOptions.DeploymentRole} of the pipeline action {actionCloudFormationOptions.Name} was not found",
$"There is no deployment role in the pipeline action {actionCloudFormationOptions.Name}");
// Locate role
role = LocateRole(actionCloudFormationOptions.Role,
$"There is no role in the pipeline action {actionCloudFormationOptions.Name}",
$"The role {actionCloudFormationOptions.Role} of the pipeline action {actionCloudFormationOptions.Name} was not found");
// Parse CfnCapabilites
cfnCapabilities = actionCloudFormationOptions.CfnCapabilities.Select(x => Enum.Parse <CfnCapabilities>(x)).ToArray();
}
private void GetEcsDeployActionResources(PipelineActionEcsDeployOptions actionEcsDeployOptions, IDictionary <string, Artifact_> artifacts, out IBaseService service, out Artifact_ artifact, out IRole role)
{
service = AwsCdkHandler.LocateEcsServiceByAttrs(actionEcsDeployOptions.Name, new Ec2ServiceAttributes
{
Cluster = LocateEcsCluster(actionEcsDeployOptions.ClusterId,
$"The cluster with {actionEcsDeployOptions.ClusterId} name does not exists",
$"The EcsService with {actionEcsDeployOptions.ClusterId} must hace a cluster"),
ServiceName = actionEcsDeployOptions.ServiceName
});
// Locate artifact
if (string.IsNullOrWhiteSpace(actionEcsDeployOptions.InputArtifact))
{
throw new ArgumentException($"There is no input artifact in the pipeline action {actionEcsDeployOptions.Name}");
}
else
{
if (!artifacts.TryGetValue(actionEcsDeployOptions.InputArtifact, out artifact))
{
throw new ArgumentException($"The artifact {actionEcsDeployOptions.InputArtifact} of the pipeline action {actionEcsDeployOptions.Name} was not found");
}
}
// Locate role
role = LocateRole(actionEcsDeployOptions.Role, $"The role {actionEcsDeployOptions.Role} of the pipeline action {actionEcsDeployOptions.Name} was not found");
}
public IStage CreateEcsDeployActionInStage(IStage stage, string actionName, IBaseService service, uint deploymentTimeout, Artifact_ inputArtifact, IRole role = null, string variableNamespace = null, double?runOrder = null) //NOSONAR number of params
{
var action = HandlerResources.AwsCdkPipelineHandler.CreateEcsDeployAction(actionName, service, deploymentTimeout, inputArtifact, role, variableNamespace, runOrder);
stage.AddAction(action);
return(stage);
}
private Amazon.CDK.AWS.CodePipeline.IStageOptions GetPipelineStage(
DeploymentEnvironment deployEnv,
string apiName,
Artifact_ cdkBuildOutput,
IRole crossAccountRole,
IRole deploymentRole,
IRole pipelineRole,
Artifact_ sourceOutputArtifact,
PipelineProject containerBuildProject)
{
var ecrStackName = $"{apiName}api-{deployEnv.EnvironmentName}-ecrrepo";
var ecrRepoName = $"{apiName}api-{deployEnv.EnvironmentName}-repo";
var ecrRegistry = $"{deployEnv.AccountId}.dkr.ecr.us-east-1.amazonaws.com";
var ecrImageId = $"{ecrRegistry}/{ecrRepoName}";
var infraStackName = $"{apiName}api-{deployEnv.EnvironmentName}-infra";
return(new Amazon.CDK.AWS.CodePipeline.StageOptions
{
StageName = $"Deploy_{deployEnv.EnvironmentName}",
Actions = new Amazon.CDK.AWS.CodePipeline.Action[]
{
new CloudFormationCreateUpdateStackAction(new CloudFormationCreateUpdateStackActionProps {
ActionName = "Create_ECR",
TemplatePath = cdkBuildOutput.AtPath($"{ecrStackName}.template.json"),
StackName = ecrStackName,
AdminPermissions = true,
Role = crossAccountRole,
DeploymentRole = deploymentRole,
CfnCapabilities = new[] { CfnCapabilities.ANONYMOUS_IAM },
RunOrder = 1
}),
new CodeBuildAction(new CodeBuildActionProps {
ActionName = "Lambda_Image_Build",
Project = containerBuildProject,
Input = sourceOutputArtifact,
Role = pipelineRole,
EnvironmentVariables = new Dictionary <string, IBuildEnvironmentVariable> {
{
"ECR_REGISTRY", new BuildEnvironmentVariable {
Type = BuildEnvironmentVariableType.PLAINTEXT,
Value = ecrRegistry
}
}, {
"ECR_IMAGE", new BuildEnvironmentVariable {
Type = BuildEnvironmentVariableType.PLAINTEXT,
Value = ecrImageId
}
}
},
RunOrder = 2
}),
new CloudFormationCreateUpdateStackAction(new CloudFormationCreateUpdateStackActionProps {
ActionName = "Deploy",
TemplatePath = cdkBuildOutput.AtPath($"{infraStackName}.template.json"),
StackName = infraStackName,
AdminPermissions = true,
Role = crossAccountRole,
DeploymentRole = deploymentRole,
CfnCapabilities = new[] { CfnCapabilities.ANONYMOUS_IAM },
ParameterOverrides = new Dictionary <string, object> {
{ "ImageTag", "#{SourceVariables.CommitId}" }
},
RunOrder = 3
})
}
});
}
public IStage CreateS3ActionInStage(IStage stage, string actionName, IBucket sourceCodeBucket, string bucketKey, Artifact_ outputArtifact, IRole role = null, S3Trigger s3Trigger = S3Trigger.POLL, double?runOrder = null) //NOSONAR number of params
{
var action = HandlerResources.AwsCdkPipelineHandler.CreateS3Action(actionName, sourceCodeBucket, bucketKey, outputArtifact, role, s3Trigger, runOrder);
stage.AddAction(action);
return(stage);
}
public EcsDeployAction CreateEcsDeployAction(string actionName, IBaseService service, uint deploymentTimeout, Artifact_ inputArtifact, IRole role = null, string variableNamespace = null, double?runOrder = null)
{
return(new EcsDeployAction(new EcsDeployActionProps
{
ActionName = actionName,
Service = service,
DeploymentTimeout = Duration.Minutes(deploymentTimeout),
Input = inputArtifact,
Role = role,
RunOrder = runOrder,
VariablesNamespace = variableNamespace
}));
}
public PipelineStack(Construct parent, string id, IPipelineStackProps props) : base(parent, id, props)
{
EcrRepository = new Repository(
this,
"EcrRepository",
new RepositoryProps
{
RepositoryName = "cdk-dotnet-example",
RemovalPolicy = RemovalPolicy.DESTROY,
});
var cdkBuild = new PipelineProject(
this,
"CdkBuild",
new PipelineProjectProps
{
BuildSpec = BuildSpec.FromSourceFilename("Infrastructure/Resources/cdk_buildspec.yml"),
Environment = new BuildEnvironment
{
BuildImage = LinuxBuildImage.AMAZON_LINUX_2,
},
});
var apiBuildTaskRole = new Role(
this,
"ApiBuildRole",
new RoleProps
{
ManagedPolicies = new[]
{
ManagedPolicy.FromAwsManagedPolicyName("AmazonEC2ContainerRegistryPowerUser"),
},
AssumedBy = new ServicePrincipal("codebuild.amazonaws.com")
});
var apiBuild = new PipelineProject(
this,
"ApiBuild",
new PipelineProjectProps
{
BuildSpec = BuildSpec.FromSourceFilename("Infrastructure/Resources/api_buildspec.yml"),
Role = apiBuildTaskRole,
Environment = new BuildEnvironment
{
BuildImage = LinuxBuildImage.AMAZON_LINUX_2,
Privileged = true,
EnvironmentVariables = new Dictionary <string, IBuildEnvironmentVariable>
{
["AWS_ACCOUNT_ID"] = CdkUtil.PlainTextBuildEnvironmentVariable(Of(this).Account),
["AWS_DEFAULT_REGION"] = CdkUtil.PlainTextBuildEnvironmentVariable(Of(this).Region),
},
},
});
var apiTest = new PipelineProject(
this,
"ApiTest",
new PipelineProjectProps
{
BuildSpec = BuildSpec.FromSourceFilename("Infrastructure/Resources/ci_buildspec.yml"),
Environment = new BuildEnvironment
{
BuildImage = LinuxBuildImage.AMAZON_LINUX_2,
Privileged = true,
},
});
var sourceOutput = new Artifact_();
var cdkBuildOutput = new Artifact_("CdkBuildOutput");
var apiBuildOutput = new Artifact_("ApiBuildOutput");
new Pipeline(
this,
"Api",
new PipelineProps
{
Stages = new IStageProps[]
{
new StageProps
{
StageName = "Source",
Actions = new IAction[]
{
new GitHubSourceAction(new GitHubSourceActionProps
{
ActionName = "GitHub",
OauthToken = SecretValue.SecretsManager(props.GitHubSecretName),
Repo = props.GitHubRepo,
Owner = props.GitHubOwner,
Output = sourceOutput,
Trigger = GitHubTrigger.WEBHOOK,
}),
},
},
new StageProps
{
StageName = "Build",
Actions = new IAction[]
{
new CodeBuildAction(new CodeBuildActionProps
{
ActionName = "ApiTest",
Project = apiTest,
Input = sourceOutput,
RunOrder = 1,
}),
new CodeBuildAction(new CodeBuildActionProps
{
ActionName = "ApiBuild",
Project = apiBuild,
Input = sourceOutput,
Outputs = new[] { apiBuildOutput },
RunOrder = 2,
}),
new CodeBuildAction(new CodeBuildActionProps
{
ActionName = "CdkBuild",
Project = cdkBuild,
Input = sourceOutput,
Outputs = new[] { cdkBuildOutput },
RunOrder = 3,
}),
},
},
new StageProps
{
StageName = "Deploy",
Actions = new IAction[]
{
new CloudFormationCreateUpdateStackAction(new CloudFormationCreateUpdateStackActionProps
{
ActionName = "ApiStack",
TemplatePath = cdkBuildOutput.AtPath($"{props.ApiStackName}.template.json"),
StackName = "Api",
AdminPermissions = true,
ParameterOverrides = new Dictionary <string, object>
{
[props.ApiImageTag] = apiBuildOutput.GetParam("metadata.json", "imageTag"),
},
ExtraInputs = new[]
{
apiBuildOutput,
},
}),
},
},
},
});
}
public S3SourceAction CreateS3Action(string actionName, IBucket sourceCodeBucket, string bucketKey, Artifact_ outputArtifact, IRole role = null, S3Trigger s3Trigger = S3Trigger.POLL, double?runOrder = null)
{
return(new S3SourceAction(new S3SourceActionProps
{
ActionName = actionName,
Bucket = sourceCodeBucket,
BucketKey = bucketKey,
Output = outputArtifact,
Trigger = s3Trigger,
Role = role,
RunOrder = runOrder
}));
}
internal CICD(
CdkStack stack,
CfnParameter targetPlatform,
LoadBalancedInstancesResult frontEndInstanceInfo,
LoadBalancedInstancesResult restAPIInstanceInfo)
{
var artifactBucket = new Bucket(stack, "ArtifactBucket");
var repo = new Repository(stack, "ApplicationRepository", new RepositoryProps
{
RepositoryName = stack.StackName,
Description = $"Contains the code for the {stack.StackName} application."
});
var cfnRepo = repo.Node.DefaultChild as Amazon.CDK.AWS.CodeCommit.CfnRepository;
cfnRepo.Code = new CfnRepository.CodeProperty
{
S3 = new CfnRepository.S3Property
{
Bucket = SourceBucketName,
Key = SourceBucketKey
}
};
var build = new PipelineProject(stack, "ApplicationBuild", new PipelineProjectProps
{
Environment = new BuildEnvironment
{
BuildImage = LinuxBuildImage.AMAZON_LINUX_2_3,
EnvironmentVariables = new Dictionary <string, IBuildEnvironmentVariable> {
{
"TARGET_OS",
new BuildEnvironmentVariable {
Type = BuildEnvironmentVariableType.PLAINTEXT,
Value = targetPlatform.Value
}
}
}
}
});
var frontEndApplication = new ServerApplication(stack, "FrontEnd", new ServerApplicationProps
{
ApplicationName = $"{stack.StackName}-FrontEnd"
});
var frontEndDeploymentGroup = new ServerDeploymentGroup(stack, "FrontEndDeploymentGroup", new ServerDeploymentGroupProps
{
Application = frontEndApplication,
DeploymentGroupName = $"{stack.StackName.ToLower()}-frontend-deployment-group",
//Role = new Role(stack, "DeploymentServiceRole", new RoleProps
//{
// AssumedBy = new ServicePrincipal("codedeploy.amazonaws.com"),
// Description = "Allows Application Deployment.",
// ManagedPolicies = new[] { ManagedPolicy.FromAwsManagedPolicyName("service-role/AWSCodeDeployRole") }
//}),
//AutoRollback = new AutoRollbackConfig { FailedDeployment = true },
//DeploymentConfig = ServerDeploymentConfig.HALF_AT_A_TIME,
LoadBalancer = LoadBalancer.Application(frontEndInstanceInfo.TargetGroup),
AutoScalingGroups = new[] { frontEndInstanceInfo.AutoScalingGroup }
});
var restApiApplication = new ServerApplication(stack, "RestAPI", new ServerApplicationProps
{
ApplicationName = $"{stack.StackName}-RESTAPI"
});
var restApiDeploymentGroup = new ServerDeploymentGroup(stack, "RestAPIDeploymentGroup", new ServerDeploymentGroupProps
{
Application = restApiApplication,
DeploymentGroupName = $"{stack.StackName.ToLower()}-restapi-deployment-group",
//AutoRollback = new AutoRollbackConfig { FailedDeployment = true },
//DeploymentConfig = ServerDeploymentConfig.HALF_AT_A_TIME,
LoadBalancer = LoadBalancer.Application(restAPIInstanceInfo.TargetGroup),
AutoScalingGroups = new[] { restAPIInstanceInfo.AutoScalingGroup }
});
var sourceOutput = new Artifact_();
var frontEndArtifacts = new Artifact_("FrontEndOutput");
var restAPIArtifacts = new Artifact_("RESTAPIOutput");
var pipeline = new Pipeline(stack, "ApplicationPipeline", new PipelineProps
{
ArtifactBucket = artifactBucket,
PipelineName = $"{stack.StackName}-Pipeline",
Stages = new[]
{
new Amazon.CDK.AWS.CodePipeline.StageProps
{
StageName = "Source",
Actions = new []
{
new CodeCommitSourceAction(new CodeCommitSourceActionProps
{
ActionName = "Source",
Repository = repo,
Output = sourceOutput
})
}
},
new Amazon.CDK.AWS.CodePipeline.StageProps
{
StageName = "Build",
Actions = new []
{
new CodeBuildAction(new CodeBuildActionProps
{
ActionName = "CodeBuild",
Project = build,
Input = sourceOutput,
Outputs = new [] { frontEndArtifacts, restAPIArtifacts }
})
}
},
new Amazon.CDK.AWS.CodePipeline.StageProps
{
StageName = "Deploy",
Actions = new []
{
new CodeDeployServerDeployAction(new CodeDeployServerDeployActionProps {
ActionName = "DeployFrontEnd",
DeploymentGroup = frontEndDeploymentGroup,
Input = frontEndArtifacts
}),
new CodeDeployServerDeployAction(new CodeDeployServerDeployActionProps {
ActionName = "DeployRESTAPI",
DeploymentGroup = restApiDeploymentGroup,
Input = restAPIArtifacts
})
}
}
}
});
}
public CiCdStack(Construct parent, string id, CiCdStackProps props) : base(parent, id, props)
{
var apiRepository =
Amazon.CDK.AWS.CodeCommit.Repository.FromRepositoryArn(this, "Repository", props.apiRepositoryArn);
var environmentVariables = new Dictionary <string, IBuildEnvironmentVariable>();
environmentVariables.Add("AWS_ACCOUNT_ID", new BuildEnvironmentVariable()
{
Type = BuildEnvironmentVariableType.PLAINTEXT,
Value = Aws.ACCOUNT_ID
});
environmentVariables.Add("AWS_DEFAULT_REGION", new BuildEnvironmentVariable()
{
Type = BuildEnvironmentVariableType.PLAINTEXT,
Value = Aws.REGION
});
var codebuildProject = new PipelineProject(this, "BuildProject", new PipelineProjectProps
{
Environment = new BuildEnvironment
{
ComputeType = ComputeType.SMALL,
BuildImage = LinuxBuildImage.UBUNTU_14_04_PYTHON_3_5_2,
Privileged = true,
EnvironmentVariables = environmentVariables
}
});
var codeBuildPolicy = new PolicyStatement();
codeBuildPolicy.AddResources(apiRepository.RepositoryArn);
codeBuildPolicy.AddActions(
"codecommit:ListBranches",
"codecommit:ListRepositories",
"codecommit:BatchGetRepositories",
"codecommit:GitPull"
);
codebuildProject.AddToRolePolicy(
codeBuildPolicy
);
props.ecrRepository.GrantPullPush(codebuildProject.GrantPrincipal);
var sourceOutput = new Artifact_();
var sourceAction = new Amazon.CDK.AWS.CodePipeline.Actions.CodeCommitSourceAction(
new Amazon.CDK.AWS.CodePipeline.Actions.CodeCommitSourceActionProps
{
ActionName = "CodeCommit-Source",
Branch = "master",
Trigger = CodeCommitTrigger.POLL,
Repository = apiRepository,
Output = sourceOutput
});
var buildOutput = new Artifact_();
var buildAction = new CodeBuildAction(new CodeBuildActionProps
{
ActionName = "Build",
Input = sourceOutput,
Outputs = new Artifact_[]
{
buildOutput
},
Project = codebuildProject
});
var deployAction = new EcsDeployAction(new EcsDeployActionProps
{
ActionName = "DeployAction",
Input = buildOutput,
Service = props.ecsService,
});
var pipeline = new Pipeline(this, "Pipeline");
pipeline.AddStage(new StageOptions
{
StageName = "Source",
Actions = new Action[] { sourceAction }
});
pipeline.AddStage(new StageOptions
{
StageName = "Build",
Actions = new Action[] { buildAction }
});
pipeline.AddStage(new StageOptions
{
StageName = "Deploy",
Actions = new Action[] { deployAction }
});
}
public IStage CreateEcrActionInStage(IStage stage, string actionName, string imageTag, Artifact_ outputArtifact, IRepository repositoryInstance, IRole role = null, string variableNamespace = null, double?runOrder = null) //NOSONAR number of params
{
var action = HandlerResources.AwsCdkPipelineHandler.CreateEcrAction(actionName, imageTag, outputArtifact, repositoryInstance, role, variableNamespace, runOrder);
stage.AddAction(action);
return(stage);
}
internal PipelineStack(Construct scope, string id, Configuration configuration, IStackProps props = null) : base(scope, id, props)
{
var repository = Repository.FromRepositoryArn(this, "Repository", configuration.Source.RepositoryArn);
var sourceArtifact = new Artifact_();
var outputArtifact = new Artifact_();
var ecrPolicy = new PolicyStatement(new PolicyStatementProps
{
Effect = Effect.ALLOW,
Actions = new[] { "ecr:*" },
Resources = new[] { "*" }
});
// Setup CodeCommit cross account role access policies if required
IRole codeCommitRole = null;
if (!string.IsNullOrWhiteSpace(configuration.Source.CrossAccountRoleArn))
{
codeCommitRole = Role.FromRoleArn(this, "CodeCommitRole", configuration.Source.CrossAccountRoleArn, new FromRoleArnOptions()
{
Mutable = false // Flag to indicate CDK to not modify the role
});
}
// Self mutation
var pipeline = new CdkPipeline(this, "Pipeline", new CdkPipelineProps
{
PipelineName = Configuration.ProjectName,
CloudAssemblyArtifact = outputArtifact,
SourceAction = new CodeCommitSourceAction(new CodeCommitSourceActionProps
{
ActionName = "CodeCommit",
Output = sourceArtifact,
Repository = repository,
Branch = configuration.Source.BranchName,
Role = codeCommitRole,
Trigger = CodeCommitTrigger.POLL
}),
// It synthesizes CDK code to cdk.out directory which is picked by SelfMutate stage to mutate the pipeline
SynthAction = new SimpleSynthAction(new SimpleSynthActionProps
{
SourceArtifact = sourceArtifact,
CloudAssemblyArtifact = outputArtifact,
Subdirectory = "LambdaRuntimeDockerfiles/dotnet5/Infrastructure",
InstallCommands = new[]
{
"npm install -g aws-cdk",
},
BuildCommands = new[] { "dotnet build" },
SynthCommand = "cdk synth",
CopyEnvironmentVariables = new[]
{
"SOURCE_REPOSITORY_ARN",
"SOURCE_BRANCH_NAME",
"SOURCE_CROSS_ACCOUNT_ROLE_ARN",
"BASE_ECRS",
"STAGE_ECR",
"BETA_ECRS",
"PROD_ECRS",
"ECR_REPOSITORY_NAME",
}
})
});
// Stage
var dockerBuild = new Project(this, "DockerBuild", new ProjectProps()
{
BuildSpec = BuildSpec.FromSourceFilename($"{Configuration.ProjectRoot}/DockerBuild/buildspec.yml"),
Description = $"Builds and pushes image to {configuration.Ecrs.Stage}",
Environment = new BuildEnvironment()
{
BuildImage = LinuxBuildImage.AMAZON_LINUX_2_3,
Privileged = true
},
Source = Amazon.CDK.AWS.CodeBuild.Source.CodeCommit(new CodeCommitSourceProps()
{
Repository = repository,
BranchOrRef = configuration.Source.BranchName
}),
EnvironmentVariables = new Dictionary <string, IBuildEnvironmentVariable>
{
{ "BASE_ECRS", new BuildEnvironmentVariable()
{
Value = configuration.Ecrs.Base
} },
{ "STAGE_ECR", new BuildEnvironmentVariable {
Value = configuration.Ecrs.Stage
} },
{ "ECR_REPOSITORY_NAME", new BuildEnvironmentVariable {
Value = configuration.EcrRepositoryName
} }
}
});
dockerBuild.AddToRolePolicy(ecrPolicy);
var dockerBuildStage = pipeline.AddStage("Stage-DockerBuild");
dockerBuildStage.AddActions(new CodeBuildAction(new CodeBuildActionProps()
{
Input = sourceArtifact,
Project = dockerBuild,
ActionName = "DockerBuild"
}));
// Beta
var betaDockerPush = new Project(this, "Beta-DockerPush", new ProjectProps()
{
BuildSpec = BuildSpec.FromSourceFilename($"{Configuration.ProjectRoot}/DockerPush/buildspec.yml"),
Description = $"Pushes staged image to {configuration.Ecrs.Beta}",
Environment = new BuildEnvironment()
{
BuildImage = LinuxBuildImage.AMAZON_LINUX_2_3,
Privileged = true
},
Source = Amazon.CDK.AWS.CodeBuild.Source.CodeCommit(new CodeCommitSourceProps()
{
Repository = repository,
BranchOrRef = configuration.Source.BranchName
}),
EnvironmentVariables = new Dictionary <string, IBuildEnvironmentVariable>
{
{ "SOURCE_ECR", new BuildEnvironmentVariable {
Value = configuration.Ecrs.Stage
} },
{ "ECR_REPOSITORY_NAME", new BuildEnvironmentVariable {
Value = configuration.EcrRepositoryName
} },
{ "DESTINATION_ECRS", new BuildEnvironmentVariable {
Value = configuration.Ecrs.Beta
} },
{ "DESTINATION_IMAGE_TAG", new BuildEnvironmentVariable {
Value = "beta"
} },
}
});
betaDockerPush.AddToRolePolicy(ecrPolicy);
var betaDockerPushStage = pipeline.AddStage("Beta-DockerPush");
betaDockerPushStage.AddActions(new CodeBuildAction(new CodeBuildActionProps()
{
Input = sourceArtifact,
Project = betaDockerPush,
ActionName = "DockerPush"
}));
// Manual Approval
var manualApprovalStage = pipeline.AddStage("Prod-ManualApproval");
manualApprovalStage.AddActions(new ManualApprovalAction(new ManualApprovalActionProps()
{
ActionName = "ManualApproval"
}));
// Prod
var prodDockerPush = new Project(this, "Prod-DockerPush", new ProjectProps()
{
BuildSpec = BuildSpec.FromSourceFilename($"{Configuration.ProjectRoot}/DockerPush/buildspec.yml"),
Description = $"Pushes staged image to {configuration.Ecrs.Prod}",
Environment = new BuildEnvironment()
{
BuildImage = LinuxBuildImage.AMAZON_LINUX_2_3,
Privileged = true
},
Source = Amazon.CDK.AWS.CodeBuild.Source.CodeCommit(new CodeCommitSourceProps()
{
Repository = repository,
BranchOrRef = "dotnet5/cdk"
}),
EnvironmentVariables = new Dictionary <string, IBuildEnvironmentVariable>
{
{ "SOURCE_ECR", new BuildEnvironmentVariable {
Value = configuration.Ecrs.Stage
} },
{ "ECR_REPOSITORY_NAME", new BuildEnvironmentVariable {
Value = configuration.EcrRepositoryName
} },
{ "DESTINATION_ECRS", new BuildEnvironmentVariable {
Value = configuration.Ecrs.Prod
} },
{ "DESTINATION_IMAGE_TAG", new BuildEnvironmentVariable {
Value = "beta"
} }, // Prod images are also tagged as beta
}
});
prodDockerPush.AddToRolePolicy(ecrPolicy);
var prodDockerPushStage = pipeline.AddStage("Prod-DockerPush");
prodDockerPushStage.AddActions(new CodeBuildAction(new CodeBuildActionProps()
{
Input = sourceArtifact,
Project = prodDockerPush,
ActionName = "DockerPush"
}));
}
public CloudFormationCreateUpdateStackAction CreateCloudFormationCreateUpdateStackAction(string actionName, Artifact_ inputArtifact, string templatePath, string stackName, IRole deploymentRole, IRole role, CfnCapabilities[] cfnCapabilities)
{
return(new CloudFormationCreateUpdateStackAction(new CloudFormationCreateUpdateStackActionProps
{
ActionName = actionName,
TemplatePath = inputArtifact.AtPath(templatePath),
StackName = stackName,
Role = role,
DeploymentRole = deploymentRole,
CfnCapabilities = cfnCapabilities
}));
}
public CodeCoveragePipelineStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
var buildProjectName = Constants.Project + Constants.BuildProject;
var buildProject = new PipelineProject(this, buildProjectName, new PipelineProjectProps
{
ProjectName = buildProjectName,
BuildSpec = BuildSpec.FromObject(new Dictionary <string, object>
{
["version"] = "0.2",
["phases"] = new Dictionary <string, object>
{
["install"] = new Dictionary <string, object>
{
["runtime-versions"] = new Dictionary <string, object>
{
["dotnet"] = "latest"
},
["commands"] = new string[]
{
"dotnet tool install -g dotnet-reportgenerator-globaltool",
"export PATH=\"$PATH:/root/.dotnet/tools\""
}
},
["build"] = new Dictionary <string, object>
{
["commands"] = new string[]
{
"dotnet build",
"dotnet test --collect:\"XPlat Code Coverage\" --logger trx",
"xmlPath=$(find $CODEBUILD_SRC_DIR/Calculator.Tests/TestResults -name \"*.xml\")",
"reportgenerator -reports:$xmlPath -targetdir:$CODEBUILD_SRC_DIR/Calculator.Tests/TestResults/"
}
}
},
["reports"] = new Dictionary <string, object>
{
[Constants.TestReportGroup] = new Dictionary <string, object>
{
["files"] = new string[]
{
"**/*.trx"
},
["base-directory"] = "$CODEBUILD_SRC_DIR/Calculator.Tests/TestResults",
["file-format"] = "VisualStudioTrx"
},
[Constants.CodeCoverageReportGroup] = new Dictionary <string, object>
{
["files"] = new string[]
{
"**/*.xml"
},
["base-directory"] = "$CODEBUILD_SRC_DIR/Calculator.Tests/TestResults",
["file-format"] = "CoberturaXml"
}
},
["artifacts"] = new Dictionary <string, object>
{
["files"] = new string[]
{
"**/*"
},
["name"] = "coverlet-$(date +%Y-%m-%d)",
["base-directory"] = "$CODEBUILD_SRC_DIR/Calculator.Tests/TestResults/"
}
}),
Environment = new BuildEnvironment
{
BuildImage = LinuxBuildImage.AMAZON_LINUX_2_3
}
});
var bucketName = "codepipeline-ap-southeast-2-822565979272";
var testReportGroupName = buildProjectName + "-" + Constants.TestReportGroup;
var testReportGroup = new CfnReportGroup(this, "TestReportGroup", new CfnReportGroupProps
{
Name = testReportGroupName,
Type = "TEST",
ExportConfig = new CfnReportGroup.ReportExportConfigProperty {
ExportConfigType = "S3",
S3Destination = new CfnReportGroup.S3ReportExportConfigProperty {
Bucket = bucketName,
Packaging = "NONE",
Path = "TestReports"
}
}
});
var codeCoverageReportGroupName = buildProjectName + "-" + Constants.CodeCoverageReportGroup;
var CodeCoverageReportGroup = new CfnReportGroup(this, "CodeCoverageReportGroup", new CfnReportGroupProps
{
Name = codeCoverageReportGroupName,
Type = "CODE_COVERAGE",
ExportConfig = new CfnReportGroup.ReportExportConfigProperty {
ExportConfigType = "S3",
S3Destination = new CfnReportGroup.S3ReportExportConfigProperty {
Bucket = bucketName,
Packaging = "NONE",
Path = "CodeCoverageReports"
}
}
});
buildProject.AddToRolePolicy(
new PolicyStatement(new PolicyStatementProps
{
Effect = Effect.ALLOW,
Actions = new []
{
"codebuild:BatchPutCodeCoverages"
},
Resources = new []
{
Fn.Join("", new string[]
{
"arn:",
Fn.Ref("AWS::Partition"),
":codebuild:",
Fn.Ref("AWS::Region"),
":",
Fn.Ref("AWS::AccountId"),
":report-group/",
buildProject.ProjectName,
"-*"
})
}
})
);
var code = Repository.FromRepositoryName(this, "TestCoverageRepo", "TestCoverageRepo");
var artifactsBucket = Bucket.FromBucketName(this, "BucketByName", bucketName);
var sourceOutput = new Artifact_("sourceArtifact");
var buildOutput = new Artifact_("buildArtifact");
var pipelineName = Constants.Project + "Pipeline";
new Pipeline(this, pipelineName, new PipelineProps
{
PipelineName = pipelineName,
ArtifactBucket = artifactsBucket,
Stages = new[]
{
new StageProps
{
StageName = "Source",
Actions = new []
{
new CodeCommitSourceAction(new CodeCommitSourceActionProps
{
ActionName = "SourceAction",
Repository = code,
Output = sourceOutput
})
}
},
new StageProps
{
StageName = "Build",
Actions = new []
{
new CodeBuildAction(new CodeBuildActionProps
{
ActionName = "BuildAction",
Project = buildProject,
Input = sourceOutput,
Outputs = new [] { buildOutput }
})
}
},
}
});
}
public IStage CreateCloudFormationCreateUpdateStackActionInStage(IStage stage, string actionName, Artifact_ inputArtifact, string templatePath, string stackName, IRole deploymentRole, IRole role, CfnCapabilities[] cfnCapabilities) //NOSONAR number of params
{
var action = HandlerResources.AwsCdkPipelineHandler.CreateCloudFormationCreateUpdateStackAction(actionName, inputArtifact, templatePath, stackName, deploymentRole, role, cfnCapabilities);
stage.AddAction(action);
return(stage);
}
