web-dev-qa-db-fra.com

AWS ECS Créer des tâches planifiées (cron) via Cloudformation

Nous voulons créer ScheduledTasks dans AWS ECS via CloudFormation. Existe-t-il un moyen programmatique de créer via boto ou cloudformation?

15
siliconsenthil

Pour définir une tâche ECS planifiée dans CloudFormation, vous devez définir une ressource "AWS :: Events :: Rule" avec une tâche ECS comme cible.

"TaskSchedule": {
  "Type": "AWS::Events::Rule",
  "Properties": {
    "Description": "dump data every workday at 10",
    "Name": "dump-data",
    "ScheduleExpression": "cron(0 10 ? * MON-FRI *)",
    "State": "ENABLED",
    "Targets": [
      {
        "Id": "dump-data-ecs-task",
        "RoleArn": {
          "Fn::GetAtt": ["TaskSchedulerRole", "Arn"]
        },
        "EcsParameters": {
          "TaskDefinitionArn": {
            "Ref": "TaskDefinition"
          },
          "TaskCount": 1
        },
        "Arn": {
          "Fn::GetAtt": ["EcsCluster", "Arn"]
        }
      }
    ]
  }
}
17
Mark

Troposphère permet désormais de définir ECS tâche planifiée, vous avez besoin de trois ressources pour cela,

  1. la définition de la tâche:

    from troposphere.ecs import (
        ContainerDefinition,
        TaskDefinition,
    )
    
    scheduled_worker_task_definition = TaskDefinition(
        "ScheduledWorkerTask",
        template=template,
        ContainerDefinitions=[
            ContainerDefinition(
                Name="ScheduledWorker",
                Cpu=200,
                Memory=300,
                Essential=True,
                Image="<image>",
                EntryPoint=['<entry_point>']
            ),  
        ],  
    )
    
  2. Le rôle pour exécuter la tâche:

    from troposphere import iam
    
    run_task_role = iam.Role(
        "RunTaskRole",
        template=template,
        AssumeRolePolicyDocument=dict(Statement=[dict(
            Effect="Allow",
            Principal=dict(Service=["events.amazonaws.com"]),
            Action=["sts:AssumeRole"],
        )]),
        Path="/",
        Policies=[
            iam.Policy(
                PolicyName="RunTaskPolicy",
                PolicyDocument=dict(
                    Statement=[dict(
                        Effect="Allow",
                        Action=[
                            "ecs:RunTask",
                        ],
                        Resource=["*"],
                        Condition=dict(
                            ArnEquals={
                                "ecs:cluster": GetAtt(cluster, "Arn"),
                            }
                        )
                    )],
                ),
            ),
        ],
    )
    
  3. La règle d'événement qui planifie la tâche:

    from troposphere.events import Rule, Target, EcsParameters
    
    Rule(
        "SchedulingRule",
        template=template,
        Description="My schedule task rule",
        State="ENABLED",
        ScheduleExpression="rate(30 minutes)",
        Targets=[
            Target(
                Id="ScheduledWorkerTaskDefinitionTarget",
                RoleArn=GetAtt(run_task_role, "Arn"),
                Arn=GetAtt(cluster, "Arn"),
                EcsParameters=EcsParameters(
                    TaskCount=1,
                    TaskDefinitionArn=Ref(scheduled_worker_task_definition),
                ),
            ),
        ]
    )
    

Où la sortie JSON ressemble à:

    ...
    "ScheduledWorkerTask": {
        "Condition": "Deploy",
        "Properties": {
            "ContainerDefinitions": [
                {
                    "Cpu": 200,
                    "EntryPoint": [
                        "<entry_point>"
                    ],
                    "Essential": "true",
                    "Image": {
                        "Fn::Join": [
                            "",
                            [
                                {
                                    "Ref": "AWS::AccountId"
                                },
                                ".dkr.ecr.",
                                {
                                    "Ref": "AWS::Region"
                                },
                                ".amazonaws.com/",
                                {
                                    "Ref": "ApplicationRepository"
                                },
                                ":",
                                "<image>"
                            ]
                        ]
                    },
                    "Memory": 300,
                    "Name": "ScheduledWorker"
                }
            ]
        },
        "Type": "AWS::ECS::TaskDefinition"
    },

    "SchedulingRule": {
        "Properties": {
            "Description": "My schedule task rule",
            "ScheduleExpression": "rate(30 minutes)",
            "State": "ENABLED",
            "Targets": [
                {
                    "Arn": {
                        "Fn::GetAtt": [
                            "Cluster",
                            "Arn"
                        ]
                    },
                    "EcsParameters": {
                        "TaskCount": 1,
                        "TaskDefinitionArn": {
                            "Ref": "ScheduledWorkerTask"
                        }
                    },
                    "Id": "ScheduledWorkerTaskDefinitionTarget",
                    "RoleArn": {
                        "Fn::GetAtt": [
                            "RunTaskRole",
                            "Arn"
                        ]
                    }
                }
            ]
        },
        "Type": "AWS::Events::Rule"
    },

    "RunTaskRole": {
        "Properties": {
            "AssumeRolePolicyDocument": {
                "Statement": [
                    {
                        "Action": [
                            "sts:AssumeRole"
                        ],
                        "Effect": "Allow",
                        "Principal": {
                            "Service": [
                                "events.amazonaws.com"
                            ]
                        }
                    }
                ]
            },
            "Path": "/",
            "Policies": [
                {
                    "PolicyDocument": {
                        "Statement": [
                            {
                                "Action": [
                                    "ecs:RunTask"
                                ],
                                "Condition": {
                                    "ArnEquals": {
                                        "ecs:cluster": {
                                            "Fn::GetAtt": [
                                                "Cluster",
                                                "Arn"
                                            ]
                                        }
                                    }
                                },
                                "Effect": "Allow",
                                "Resource": [
                                    "*"
                                ]
                            }
                        ]
                    },
                    "PolicyName": "RunTaskPolicy"
                }
            ]
        },
        "Type": "AWS::IAM::Role"
    },
    ...

Plus d'informations sur https://jeanphix.github.io/2017/10/04/ecs-scheduled-cron-task-with-cloudformation/

6
jeanphix

Vous pouvez le faire avec boto et cloudformation. Si vous le faites avec cloudformation, vous devrez utiliser un ressource personnalisée soutenue par Lambda . Et vous pouvez aussi le faire avec Troposphere.

Exemple de troposphère:

# Read in the code
fname = "lambda_code.py"
try:
  with open(fname) as target:
    code = target.readlines()
except Exception as e:
  print(e)

# Create the custom resource.
CustomResource = template.add_resource(Function(
  "CustomResource",
  Description="Creates and Runs a Lambda function.",
  FunctionName="myFunctionName",
  Code=Code(
    ZipFile=Join("",code)
  ),
  Runtime="python2.7",
  Role=GetAtt("lambaRole","Arn"),
  Handler="index.decide_action",
  MemorySize='128',
  Timeout='10'
))      

Quant à la création de tâches dans boto, consultez la Documentation Boto .

Ressources supplémentaires:

1
Sathed