示例#1
0
        protected override async Task <bool> PerformActionAsync()
        {
            var skipPush          = this.GetBoolValueOrDefault(this.DeployServiceProperties.SkipImagePush, ECSDefinedCommandOptions.ARGUMENT_SKIP_IMAGE_PUSH, false).GetValueOrDefault();
            var ecsContainer      = this.GetStringValueOrDefault(this.TaskDefinitionProperties.ContainerName, ECSDefinedCommandOptions.ARGUMENT_CONTAINER_NAME, true);
            var ecsTaskDefinition = this.GetStringValueOrDefault(this.TaskDefinitionProperties.TaskDefinitionName, ECSDefinedCommandOptions.ARGUMENT_TD_NAME, true);


            this.PushDockerImageProperties.DockerImageTag = this.GetStringValueOrDefault(this.PushDockerImageProperties.DockerImageTag, ECSDefinedCommandOptions.ARGUMENT_DOCKER_TAG, true).ToLower();

            if (!this.PushDockerImageProperties.DockerImageTag.Contains(":"))
            {
                this.PushDockerImageProperties.DockerImageTag += ":latest";
            }

            if (skipPush)
            {
                this.PushDockerImageProperties.DockerImageTag = await ECSUtilities.ExpandImageTagIfNecessary(this.Logger, this.ECRClient, this.PushDockerImageProperties.DockerImageTag);
            }
            else
            {
                var pushCommand = new PushDockerImageCommand(this.Logger, this.WorkingDirectory, this.OriginalCommandLineArguments)
                {
                    ConfigFile         = this.ConfigFile,
                    DisableInteractive = this.DisableInteractive,
                    Credentials        = this.Credentials,
                    ECRClient          = this.ECRClient,
                    Profile            = this.Profile,
                    ProfileLocation    = this.ProfileLocation,
                    ProjectLocation    = this.ProjectLocation,
                    Region             = this.Region,
                    WorkingDirectory   = this.WorkingDirectory,

                    PushDockerImageProperties = this.PushDockerImageProperties,
                };
                var success = await pushCommand.ExecuteAsync();

                if (!success)
                {
                    return(false);
                }

                this.PushDockerImageProperties.DockerImageTag = pushCommand.PushedImageUri;
            }


            var taskDefinitionArn = await ECSUtilities.CreateOrUpdateTaskDefinition(this.Logger, this.ECSClient,
                                                                                    this, this.TaskDefinitionProperties, this.PushDockerImageProperties.DockerImageTag, IsFargateLaunch(this.ClusterProperties.LaunchType));

            var ecsCluster = this.GetStringValueOrDefault(this.ClusterProperties.ECSCluster, ECSDefinedCommandOptions.ARGUMENT_ECS_CLUSTER, true);
            await ECSUtilities.EnsureClusterExistsAsync(this.Logger, this.ECSClient, ecsCluster);

            var ecsService = this.GetStringValueOrDefault(this.DeployServiceProperties.ECSService, ECSDefinedCommandOptions.ARGUMENT_ECS_SERVICE, true);

            await CreateOrUpdateService(ecsCluster, ecsService, taskDefinitionArn, ecsContainer);

            this.Logger?.WriteLine($"Service {ecsService} on ECS cluster {ecsCluster} has been updated. The Cluster will now deploy the new service version.");


            return(true);
        }
        public override async Task <bool> ExecuteAsync()
        {
            try
            {
                var skipPush          = this.GetBoolValueOrDefault(this.DeployTaskProperties.SkipImagePush, ECSDefinedCommandOptions.ARGUMENT_SKIP_IMAGE_PUSH, false).GetValueOrDefault();
                var ecsContainer      = this.GetStringValueOrDefault(this.TaskDefinitionProperties.ContainerName, ECSDefinedCommandOptions.ARGUMENT_CONTAINER_NAME, true);
                var ecsTaskDefinition = this.GetStringValueOrDefault(this.TaskDefinitionProperties.TaskDefinitionName, ECSDefinedCommandOptions.ARGUMENT_TD_NAME, true);


                this.PushDockerImageProperties.DockerImageTag = this.GetStringValueOrDefault(this.PushDockerImageProperties.DockerImageTag, ECSDefinedCommandOptions.ARGUMENT_DOCKER_TAG, true).ToLower();

                if (!this.PushDockerImageProperties.DockerImageTag.Contains(":"))
                {
                    this.PushDockerImageProperties.DockerImageTag += ":latest";
                }

                if (skipPush)
                {
                    this.PushDockerImageProperties.DockerImageTag = await ECSUtilities.ExpandImageTagIfNecessary(this.Logger, this.ECRClient, this.PushDockerImageProperties.DockerImageTag);
                }
                else
                {
                    var pushCommand = new PushDockerImageCommand(this.Logger, this.WorkingDirectory, this.OriginalCommandLineArguments)
                    {
                        ConfigFile         = this.ConfigFile,
                        DisableInteractive = this.DisableInteractive,
                        Credentials        = this.Credentials,
                        ECRClient          = this.ECRClient,
                        Profile            = this.Profile,
                        ProfileLocation    = this.ProfileLocation,
                        ProjectLocation    = this.ProjectLocation,
                        Region             = this.Region,
                        WorkingDirectory   = this.WorkingDirectory,

                        PushDockerImageProperties = this.PushDockerImageProperties,
                    };
                    var success = await pushCommand.ExecuteAsync();

                    if (!success)
                    {
                        return(false);
                    }

                    this.PushDockerImageProperties.DockerImageTag = pushCommand.PushedImageUri;
                }

                var taskDefinitionArn = await ECSUtilities.CreateOrUpdateTaskDefinition(this.Logger, this.ECSClient,
                                                                                        this, this.TaskDefinitionProperties, this.PushDockerImageProperties.DockerImageTag, IsFargateLaunch(this.ClusterProperties.LaunchType));

                var ecsCluster = this.GetStringValueOrDefault(this.ClusterProperties.ECSCluster, ECSDefinedCommandOptions.ARGUMENT_ECS_CLUSTER, true);
                await ECSUtilities.EnsureClusterExistsAsync(this.Logger, this.ECSClient, ecsCluster);

                var taskCount = this.GetIntValueOrDefault(this.DeployTaskProperties.TaskCount, ECSDefinedCommandOptions.ARGUMENT_ECS_TASK_COUNT, false);
                if (!taskCount.HasValue)
                {
                    taskCount = 1;
                }

                var taskGroup  = this.GetStringValueOrDefault(this.DeployTaskProperties.TaskGroup, ECSDefinedCommandOptions.ARGUMENT_ECS_TASK_GROUP, false);
                var launchType = this.GetStringValueOrDefault(this.ClusterProperties.LaunchType, ECSDefinedCommandOptions.ARGUMENT_LAUNCH_TYPE, true);

                var runTaskRequest = new Amazon.ECS.Model.RunTaskRequest
                {
                    Cluster        = ecsCluster,
                    TaskDefinition = taskDefinitionArn,
                    Count          = taskCount.Value,
                    LaunchType     = launchType
                };

                if (IsFargateLaunch(this.ClusterProperties.LaunchType))
                {
                    var subnets        = this.GetStringValuesOrDefault(this.ClusterProperties.SubnetIds, ECSDefinedCommandOptions.ARGUMENT_LAUNCH_SUBNETS, false);
                    var securityGroups = this.GetStringValuesOrDefault(this.ClusterProperties.SecurityGroupIds, ECSDefinedCommandOptions.ARGUMENT_LAUNCH_SECURITYGROUPS, false);

                    var networkConfiguration = new Amazon.ECS.Model.NetworkConfiguration();
                    await ECSUtilities.SetupAwsVpcNetworkConfigurationAsync(this, networkConfiguration);

                    runTaskRequest.NetworkConfiguration = networkConfiguration;

                    await this.AttemptToCreateServiceLinkRoleAsync();
                }
                else
                {
                    runTaskRequest.PlacementConstraints = ECSUtilities.ConvertPlacementConstraint(this.GetStringValuesOrDefault(this.DeployTaskProperties.PlacementConstraints, ECSDefinedCommandOptions.ARGUMENT_PLACEMENT_CONSTRAINTS, false));
                    runTaskRequest.PlacementStrategy    = ECSUtilities.ConvertPlacementStrategy(this.GetStringValuesOrDefault(this.DeployTaskProperties.PlacementStrategy, ECSDefinedCommandOptions.ARGUMENT_PLACEMENT_STRATEGY, false));
                }

                if (!string.IsNullOrEmpty(taskGroup))
                {
                    runTaskRequest.Group = taskGroup;
                }


                try
                {
                    var response = await this.ECSClient.RunTaskAsync(runTaskRequest);

                    this.Logger?.WriteLine($"Started {response.Tasks.Count} task:");
                    foreach (var task in response.Tasks)
                    {
                        this.Logger?.WriteLine($"\t{task.TaskArn}");
                    }
                }
                catch (Exception e)
                {
                    throw new DockerToolsException("Error executing deploy-task: " + e.Message, DockerToolsException.ECSErrorCode.RunTaskFail);
                }

                if (this.GetBoolValueOrDefault(this.PersistConfigFile, CommonDefinedCommandOptions.ARGUMENT_PERSIST_CONFIG_FILE, false).GetValueOrDefault())
                {
                    this.SaveConfigFile();
                }
            }
            catch (DockerToolsException e)
            {
                this.Logger?.WriteLine(e.Message);
                this.LastToolsException = e;
                return(false);
            }
            catch (Exception e)
            {
                this.Logger?.WriteLine($"Unknown error executing deploy-task: {e.Message}");
                this.Logger?.WriteLine(e.StackTrace);
                return(false);
            }
            return(true);
        }
示例#3
0
        protected override async Task <bool> PerformActionAsync()
        {
            var skipPush           = this.GetBoolValueOrDefault(this.DeployScheduledTaskProperties.SkipImagePush, ECSDefinedCommandOptions.ARGUMENT_SKIP_IMAGE_PUSH, false).GetValueOrDefault();
            var ecsContainer       = this.GetStringValueOrDefault(this.TaskDefinitionProperties.ContainerName, ECSDefinedCommandOptions.ARGUMENT_CONTAINER_NAME, true);
            var ecsTaskDefinition  = this.GetStringValueOrDefault(this.TaskDefinitionProperties.TaskDefinitionName, ECSDefinedCommandOptions.ARGUMENT_TD_NAME, true);
            var ecsPlatformVersion = this.GetStringValueOrDefault(this.TaskDefinitionProperties.TaskPlatformVersion, ECSDefinedCommandOptions.ARGUMENT_TD_PLATFORM_VERSION, false);

            this.PushDockerImageProperties.DockerImageTag = GetDockerImageTag();

            if (!this.PushDockerImageProperties.DockerImageTag.Contains(":"))
            {
                this.PushDockerImageProperties.DockerImageTag += ":latest";
            }

            if (skipPush)
            {
                this.PushDockerImageProperties.DockerImageTag = await ECSUtilities.ExpandImageTagIfNecessary(this.Logger, this.ECRClient, this.PushDockerImageProperties.DockerImageTag);
            }
            else
            {
                var pushCommand = new PushDockerImageCommand(this.Logger, this.WorkingDirectory, this.OriginalCommandLineArguments)
                {
                    ConfigFile         = this.ConfigFile,
                    DisableInteractive = this.DisableInteractive,
                    Credentials        = this.Credentials,
                    ECRClient          = this.ECRClient,
                    Profile            = this.Profile,
                    ProfileLocation    = this.ProfileLocation,
                    ProjectLocation    = this.ProjectLocation,
                    Region             = this.Region,
                    WorkingDirectory   = this.WorkingDirectory,

                    PushDockerImageProperties = this.PushDockerImageProperties,
                };
                var success = await pushCommand.ExecuteAsync();

                if (!success)
                {
                    return(false);
                }

                this.PushDockerImageProperties.DockerImageTag = pushCommand.PushedImageUri;
            }

            var taskDefinitionArn = await ECSUtilities.CreateOrUpdateTaskDefinition(this.Logger, this.ECSClient,
                                                                                    this, this.TaskDefinitionProperties, this.PushDockerImageProperties.DockerImageTag, IsFargateLaunch(this.ClusterProperties.LaunchType));

            var ecsCluster = this.GetStringValueOrDefault(this.ClusterProperties.ECSCluster, ECSDefinedCommandOptions.ARGUMENT_ECS_CLUSTER, true);
            await ECSUtilities.EnsureClusterExistsAsync(this.Logger, this.ECSClient, ecsCluster);

            if (!ecsCluster.Contains(":"))
            {
                var arnPrefix = taskDefinitionArn.Substring(0, taskDefinitionArn.LastIndexOf(":task"));
                ecsCluster = arnPrefix + ":cluster/" + ecsCluster;
            }

            var ruleName   = this.GetStringValueOrDefault(this.DeployScheduledTaskProperties.ScheduleTaskRule, ECSDefinedCommandOptions.ARGUMENT_SCHEDULED_RULE_NAME, true);
            var targetName = this.GetStringValueOrDefault(this.DeployScheduledTaskProperties.ScheduleTaskRuleTarget, ECSDefinedCommandOptions.ARGUMENT_SCHEDULED_RULE_TARGET, false);

            if (string.IsNullOrEmpty(targetName))
            {
                targetName = ruleName;
            }

            var scheduleExpression = this.GetStringValueOrDefault(this.DeployScheduledTaskProperties.ScheduleExpression, ECSDefinedCommandOptions.ARGUMENT_SCHEDULE_EXPRESSION, true);
            var cweRole            = this.GetStringValueOrDefault(this.DeployScheduledTaskProperties.CloudWatchEventIAMRole, ECSDefinedCommandOptions.ARGUMENT_CLOUDWATCHEVENT_ROLE, true);
            var desiredCount       = this.GetIntValueOrDefault(this.DeployScheduledTaskProperties.DesiredCount, ECSDefinedCommandOptions.ARGUMENT_ECS_DESIRED_COUNT, false);

            if (!desiredCount.HasValue)
            {
                desiredCount = 1;
            }

            var launchType    = this.GetStringValueOrDefault(this.ClusterProperties.LaunchType, ECSDefinedCommandOptions.ARGUMENT_LAUNCH_TYPE, true);
            var ecsParameters = new EcsParameters
            {
                TaskCount         = desiredCount.Value,
                TaskDefinitionArn = taskDefinitionArn,
                LaunchType        = launchType
            };

            if (IsFargateLaunch(this.ClusterProperties.LaunchType))
            {
                var networkConfiguration = new Amazon.CloudWatchEvents.Model.NetworkConfiguration();
                await ECSUtilities.SetupAwsVpcNetworkConfigurationCloudwatchEventAsync(this, networkConfiguration);

                ecsParameters.NetworkConfiguration = networkConfiguration;
                ecsParameters.PlatformVersion      = ecsPlatformVersion;

                await this.AttemptToCreateServiceLinkRoleAsync();
            }

            string ruleArn = null;

            try
            {
                ruleArn = (await this.CWEClient.PutRuleAsync(new PutRuleRequest
                {
                    Name = ruleName,
                    ScheduleExpression = scheduleExpression,
                    State = RuleState.ENABLED
                })).RuleArn;

                this.Logger?.WriteLine($"Put CloudWatch Event rule {ruleName} with expression {scheduleExpression}");
            }
            catch (Exception e)
            {
                throw new DockerToolsException("Error creating CloudWatch Event rule: " + e.Message, DockerToolsException.ECSErrorCode.PutRuleFail);
            }

            try
            {
                await this.CWEClient.PutTargetsAsync(new PutTargetsRequest
                {
                    Rule    = ruleName,
                    Targets = new List <Target>
                    {
                        new Target
                        {
                            Arn           = ecsCluster,
                            RoleArn       = cweRole,
                            Id            = targetName,
                            EcsParameters = ecsParameters
                        }
                    }
                });

                this.Logger?.WriteLine($"Put CloudWatch Event target {targetName}");
            }
            catch (Exception e)
            {
                throw new DockerToolsException("Error creating CloudWatch Event target: " + e.Message, DockerToolsException.ECSErrorCode.PutTargetFail);
            }

            return(true);
        }