public CreateDeploymentResponse DeployToStack( AmazonCodeDeployClient codeDeployClient, AmazonIdentityManagementServiceClient iamClient, AmazonAutoScalingClient autoScalingClient, Role role) { var deploymentGroupName = _stackName + "_" + BundleName; EnsureDeploymentGroupExistsForBundle(codeDeployClient, iamClient, autoScalingClient, role, deploymentGroupName); var deploymentResponse = codeDeployClient.CreateDeployment(new CreateDeploymentRequest { ApplicationName = CodeDeployApplicationName, DeploymentGroupName = deploymentGroupName, Revision = new RevisionLocation { RevisionType = RevisionLocationType.S3, S3Location = new S3Location { Bucket = Bucket, Key = FileName, BundleType = BundleType.Zip, ETag = ETag } } }); return(deploymentResponse); }
/// <summary> /// Gets the deployment info /// </summary> /// <param name="deploymentID">A deployment ID associated with the applicable IAM user or AWS account.</param> /// <param name="settings">The <see cref="DeploySettings"/> used during the request to AWS.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> public async Task <DeploymentInfo> GetDeploymentInfo(string deploymentID, DeploySettings settings, CancellationToken cancellationToken = default(CancellationToken)) { if (String.IsNullOrEmpty(deploymentID)) { throw new ArgumentNullException("deploymentID"); } // Create Request AmazonCodeDeployClient client = this.CreateClient(settings); GetDeploymentRequest request = new GetDeploymentRequest(); request.DeploymentId = deploymentID; // Check Response GetDeploymentResponse response = await client.GetDeploymentAsync(request, cancellationToken); if (response.HttpStatusCode == HttpStatusCode.OK) { _Log.Verbose("Successfully found deployment info '{0}'", deploymentID); return(response.DeploymentInfo); } else { _Log.Error("Failed to get deployment info '{0}'", deploymentID); return(null); } }
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems) { AmazonCodeDeployConfig config = new AmazonCodeDeployConfig(); config.RegionEndpoint = region; ConfigureClient(config); AmazonCodeDeployClient client = new AmazonCodeDeployClient(creds, config); ListDeploymentConfigsResponse resp = new ListDeploymentConfigsResponse(); do { ListDeploymentConfigsRequest req = new ListDeploymentConfigsRequest { NextToken = resp.NextToken }; resp = client.ListDeploymentConfigs(req); CheckError(resp.HttpStatusCode, "200"); foreach (var obj in resp.DeploymentConfigsList) { AddObject(obj); } }while (!string.IsNullOrEmpty(resp.NextToken)); }
public static void DeleteStack(RegionEndpoint awsEndpoint, string stackName) { var codeDeployClient = new AmazonCodeDeployClient(awsEndpoint); var apps = codeDeployClient.ListApplications().Applications.Where(name => name.StartsWith("HelloWorld")); foreach (var app in apps) { codeDeployClient.DeleteApplication(new DeleteApplicationRequest { ApplicationName = app }); } var cloudFormationClient = new AmazonCloudFormationClient(awsEndpoint); try { cloudFormationClient.DeleteStack(new DeleteStackRequest { StackName = stackName }); var testStackStatus = StackStatus.DELETE_IN_PROGRESS; while (testStackStatus == StackStatus.DELETE_IN_PROGRESS) { Thread.Sleep(TimeSpan.FromSeconds(10)); var stacksStatus = cloudFormationClient.DescribeStacks(new DescribeStacksRequest { StackName = stackName }); testStackStatus = stacksStatus.Stacks.First(s => s.StackName == stackName).StackStatus; } } catch (AmazonCloudFormationException) { } }
/// <summary> /// A simple function that takes a string and does a ToUpper /// </summary> /// <param name="input"></param> /// <param name="context"></param> /// <returns></returns> public async Task <string> FunctionHandler(CodeDeployInvokeRequest input, ILambdaContext context) { String envId = input.EnvironmentId; String appName = input.ApplicationName; AmazonCodeDeployClient client = new AmazonCodeDeployClient(); var request = new CreateDeploymentRequest(); request.ApplicationName = appName; request.DeploymentGroupName = input.DeploymentGroup; request.Description = "Testing Deployment created by Lambda"; request.Revision = new RevisionLocation() { RevisionType = Amazon.CodeDeploy.RevisionLocationType.S3, S3Location = new S3Location() { Bucket = input.S3BucketName, BucketType = Amazon.CodeDeploy.BundleType.Zip, Key = input.S3KeyName } }; var response = await client.CreateDeploymentAsync(request); return(response.ToString()); }
public string Push(AmazonS3Client s3Client, AmazonCodeDeployClient codeDeployClient) { var zipFileName = string.Format("{0}.{1}.{2}.zip", ApplicationSetName, Version, BundleName); var tempPath = Path.Combine(Path.GetTempPath(), zipFileName + "." + Guid.NewGuid() + ".zip"); ZipFile.CreateFromDirectory(_bundleDirectory.FullName, tempPath, CompressionLevel.Optimal, false, Encoding.ASCII); var allTheBuckets = s3Client.ListBuckets(new ListBucketsRequest()).Buckets; if (!allTheBuckets.Exists(b => b.BucketName == Bucket)) { s3Client.PutBucket(new PutBucketRequest { BucketName = Bucket, UseClientRegion = true }); } var putResponse = s3Client.PutObject(new PutObjectRequest { BucketName = Bucket, Key = zipFileName, FilePath = tempPath, }); var registration = new RegisterApplicationRevisionRequest { ApplicationName = CodeDeployApplicationName, Description = "Revision " + Version, Revision = new RevisionLocation { RevisionType = RevisionLocationType.S3, S3Location = new S3Location { Bucket = Bucket, BundleType = BundleType.Zip, Key = zipFileName, Version = Version } } }; try { codeDeployClient.RegisterApplicationRevision(registration); } catch (ApplicationDoesNotExistException) { codeDeployClient.CreateApplication(new CreateApplicationRequest { ApplicationName = CodeDeployApplicationName }); codeDeployClient.RegisterApplicationRevision(registration); } return(putResponse.ETag); }
public async Task <string> Handler(CodeDeployRequest request) { AmazonCodeDeployClient client = new AmazonCodeDeployClient(); PutLifecycleEventHookExecutionStatusRequest req = new PutLifecycleEventHookExecutionStatusRequest(); req.DeploymentId = request.DeploymentId; req.LifecycleEventHookExecutionId = request.LifecycleEventHookExecutionId; // SET STATUS TO Failed or Succeeded based on CUSTOM LOGIC req.Status = "Succeeded"; await client.PutLifecycleEventHookExecutionStatusAsync(req); return("Go Serverless v1.0! Your function executed successfully!"); }
/// <summary> /// Deploys an application revision through the specified deployment group. /// </summary> /// <param name="applicationName">The name of an AWS CodeDeploy application associated with the applicable IAM user or AWS account.</param> /// <param name="deploymentGroup">The name of the deployment group.</param> /// <param name="settings">The <see cref="DeploySettings"/> used during the request to AWS.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> public async Task <bool> CreateDeployment(string applicationName, string deploymentGroup, DeploySettings settings, CancellationToken cancellationToken = default(CancellationToken)) { if (String.IsNullOrEmpty(applicationName)) { throw new ArgumentNullException("applicationName"); } if (String.IsNullOrEmpty(deploymentGroup)) { throw new ArgumentNullException("deploymentGroup"); } // Create Request AmazonCodeDeployClient client = this.CreateClient(settings); CreateDeploymentRequest request = new CreateDeploymentRequest(); request.ApplicationName = applicationName; request.DeploymentGroupName = deploymentGroup; request.Revision = new RevisionLocation() { RevisionType = RevisionLocationType.S3, S3Location = new S3Location() { BundleType = BundleType.Zip, Bucket = settings.S3Bucket, Key = settings.S3Key, Version = settings.S3Version } }; // Check Response CreateDeploymentResponse response = await client.CreateDeploymentAsync(request, cancellationToken); if (response.HttpStatusCode == HttpStatusCode.OK) { _Log.Verbose("Successfully deployed application '{0}'", applicationName); return(true); } else { _Log.Error("Failed to deploy application '{0}'", applicationName); return(false); } }
protected IAmazonCodeDeploy CreateClient(AWSCredentials credentials, RegionEndpoint region) { var config = new AmazonCodeDeployConfig { RegionEndpoint = region }; Amazon.PowerShell.Utils.Common.PopulateConfig(this, config); this.CustomizeClientConfig(config); var client = new AmazonCodeDeployClient(credentials, config); client.BeforeRequestEvent += RequestEventHandler; client.AfterResponseEvent += ResponseEventHandler; return(client); }
internal static string Deploy(string applicationName, string deploymentGroupName, string bucket, string key, string eTag, string version, string region = "") { try { S3Location location = new S3Location() { Bucket = bucket, BundleType = BundleType.Zip, ETag = eTag, Key = key, Version = version }; CreateDeploymentRequest request = new CreateDeploymentRequest() { ApplicationName = applicationName, DeploymentGroupName = deploymentGroupName, Revision = new RevisionLocation() { S3Location = location, RevisionType = RevisionLocationType.S3 }, }; AmazonCodeDeployClient client = string.IsNullOrEmpty(region) ? new AmazonCodeDeployClient() : new AmazonCodeDeployClient(RegionEndpoint.GetBySystemName(region)); Task <CreateDeploymentResponse> response = client.CreateDeploymentAsync(request); Task.WaitAll(new Task[] { response }); string message = "Deployment Created: {0} \ndotnet codedeploy status --deployment-id {0}"; if (!string.IsNullOrEmpty(region)) { message += " --region {1}"; } Log.Information(message, response.Result.DeploymentId, region); return(response.Result.DeploymentId); } catch (System.Exception e) { Log.Error($"{e.GetBaseException().GetType().Name}: {e.Message}"); return(null); } }
internal static GetDeploymentResponse GetDeployment(string deploymentId, string region) { try { GetDeploymentRequest request = new GetDeploymentRequest() { DeploymentId = deploymentId }; AmazonCodeDeployClient client = string.IsNullOrEmpty(region) ? new AmazonCodeDeployClient() : new AmazonCodeDeployClient(RegionEndpoint.GetBySystemName(region)); Task <GetDeploymentResponse> response = client.GetDeploymentAsync(request); Task.WaitAll(new Task[] { response }); return(response.Result); } catch (System.Exception e) { Log.Error($"{e.GetBaseException().GetType().Name}: {e.Message}"); return(null); } }
void EnsureDeploymentGroupExistsForBundle(AmazonCodeDeployClient codeDeployClient, AmazonIdentityManagementServiceClient iamClient, AmazonAutoScalingClient autoScalingClient, Role role, string deploymentGroupName) { var serviceRoleArn = role.Arn; if (TargetsAutoScalingDeploymentGroup) { var group = autoScalingClient.DescribeAutoScalingGroups() .AutoScalingGroups.FirstOrDefault( asg => asg.Tags.Any(t => t.Key == "DeploymentRole" && t.Value == deploymentGroupName)); if (group == null) { throw new ApplicationException( string.Format("Auto scaling group with DeploymentRole {0} does not exist.", deploymentGroupName)); } try { codeDeployClient.CreateDeploymentGroup(new CreateDeploymentGroupRequest { ApplicationName = CodeDeployApplicationName, DeploymentGroupName = deploymentGroupName, ServiceRoleArn = serviceRoleArn, AutoScalingGroups = new List <string> { group.AutoScalingGroupName } }); } catch (DeploymentGroupAlreadyExistsException) { // reuse a previously created deployment group with the same name } } else { try { Console.WriteLine("Will assume role {0} for deployment", serviceRoleArn); codeDeployClient.CreateDeploymentGroup(new CreateDeploymentGroupRequest { ApplicationName = CodeDeployApplicationName, DeploymentGroupName = deploymentGroupName, ServiceRoleArn = serviceRoleArn, Ec2TagFilters = new List <EC2TagFilter> { new EC2TagFilter { Type = EC2TagFilterType.KEY_AND_VALUE, Key = "DeploymentRole", Value = deploymentGroupName } } }); } catch (DeploymentGroupAlreadyExistsException) { // since this is EC2, we can reuse a previously created deployment group with the same name } } }
public Deployer(AwsConfiguration awsConfiguration) { _awsEndpoint = awsConfiguration.AwsEndpoint; _bucket = awsConfiguration.Bucket; _assumeRoleTrustDocument = awsConfiguration.AssumeRoleTrustDocument; _iamRolePolicyDocument = awsConfiguration.IamRolePolicyDocument; AWSCredentials credentials; if (isArn(awsConfiguration.RoleName)) { var securityTokenServiceClient = new AmazonSecurityTokenServiceClient(awsConfiguration.AwsEndpoint); var assumeRoleResult = securityTokenServiceClient.AssumeRole(new AssumeRoleRequest { RoleArn = awsConfiguration.RoleName, DurationSeconds = 3600, RoleSessionName = "Net2User", ExternalId = Guid.NewGuid().ToString() }); Credentials stsCredentials = assumeRoleResult.Credentials; SessionAWSCredentials sessionCredentials = new SessionAWSCredentials(stsCredentials.AccessKeyId, stsCredentials.SecretAccessKey, stsCredentials.SessionToken); credentials = sessionCredentials; _role = new AssumedRole(assumeRoleResult.AssumedRoleUser); } else { credentials = awsConfiguration.Credentials ?? new EnvironmentAWSCredentials(); } _codeDeployClient = new AmazonCodeDeployClient( credentials, new AmazonCodeDeployConfig { RegionEndpoint = awsConfiguration.AwsEndpoint, ProxyHost = awsConfiguration.ProxyHost, ProxyPort = awsConfiguration.ProxyPort }); _cloudFormationClient = new AmazonCloudFormationClient( credentials, new AmazonCloudFormationConfig { RegionEndpoint = awsConfiguration.AwsEndpoint, ProxyHost = awsConfiguration.ProxyHost, ProxyPort = awsConfiguration.ProxyPort }); _s3Client = new AmazonS3Client( credentials, new AmazonS3Config { RegionEndpoint = awsConfiguration.AwsEndpoint, ProxyHost = awsConfiguration.ProxyHost, ProxyPort = awsConfiguration.ProxyPort }); _iamClient = new AmazonIdentityManagementServiceClient( credentials, new AmazonIdentityManagementServiceConfig { RegionEndpoint = awsConfiguration.AwsEndpoint, ProxyHost = awsConfiguration.ProxyHost, ProxyPort = awsConfiguration.ProxyPort }); _autoScalingClient = new AmazonAutoScalingClient( credentials, new AmazonAutoScalingConfig { RegionEndpoint = awsConfiguration.AwsEndpoint, ProxyHost = awsConfiguration.ProxyHost, ProxyPort = awsConfiguration.ProxyPort }); }