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?

amazon-web-servicesamazon-cloudformationamazon-ecs
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