Simple EC2 based ECS blueprint (#14)

Probably some code cleanup/sharing I could do here that would make this
a bit smaller, but I didn't have a ton of time to get into it.  Probably
something worth doing in the future though.

Author: phobologic

stacker_blueprints/ecs.py

@@ -13,6 +13,7 @@
 )
 
 from stacker.blueprints.base import Blueprint
+from stacker.blueprints.variables.types import TroposphereType
 
 from .policies import ecs_task_execution_policy
 
@@ -281,3 +282,188 @@ def create_template(self):
         self.create_task_execution_role_policy()
         self.create_task_definition()
         self.create_service()
+
+
+class SimpleECSService(Blueprint):
+    VARIABLES = {
+        "ServiceName": {
+            "type": str,
+            "description": "A simple name for the service.",
+        },
+        "Image": {
+            "type": str,
+            "description": "The docker image to use for the task.",
+        },
+        "Command": {
+            "type": list,
+            "description": "A list of the command and it's arguments to run "
+                           "inside the container. If not provided, will "
+                           "default to the default command defined in the "
+                           "image.",
+            "default": [],
+        },
+        "Cluster": {
+            "type": str,
+            "description": "The name or Amazon Resource Name (ARN) of the "
+                           "ECS cluster that you want to run your tasks on.",
+        },
+        "CPU": {
+            "type": int,
+            "description": "The relative CPU shares used by each instance of "
+                           "the task.",
+        },
+        "Memory": {
+            "type": int,
+            "description": "The amount of memory (in megabytes) to reserve "
+                           "for each instance of the task.",
+        },
+        "Count": {
+            "type": int,
+            "description": "The number of instances of the task to create.",
+            "default": 1,
+        },
+        "Environment": {
+            "type": dict,
+            "description": "A dictionary representing the environment of the "
+                           "task.",
+            "default": {},
+        },
+        "LogConfiguration": {
+            "type": TroposphereType(ecs.LogConfiguration, optional=True),
+            "description": "An optional log configuration object.",
+            "default": None,
+        },
+    }
+
+    @property
+    def service_name(self):
+        return self.get_variables()["ServiceName"]
+
+    @property
+    def image(self):
+        return self.get_variables()["Image"]
+
+    @property
+    def command(self):
+        return self.get_variables()["Command"] or NoValue
+
+    @property
+    def cluster(self):
+        return self.get_variables()["Cluster"]
+
+    @property
+    def cpu(self):
+        return self.get_variables()["CPU"]
+
+    @property
+    def memory(self):
+        return self.get_variables()["Memory"]
+
+    @property
+    def count(self):
+        return self.get_variables()["Count"]
+
+    @property
+    def environment(self):
+        env_dict = self.get_variables()["Environment"]
+        if not env_dict:
+            return NoValue
+
+        env_list = []
+        for k, v in env_dict.items():
+            env_list.append(ecs.Environment(Name=str(k), Value=str(v)))
+
+        return env_list
+
+    @property
+    def log_configuration(self):
+        log_config = self.get_variables()["LogConfiguration"]
+        return log_config or NoValue
+
+    def add_output(self, key, value):
+        self.template.add_output(Output(key, Value=value))
+
+    def create_role(self):
+        t = self.template
+
+        self.role = t.add_resource(
+            iam.Role(
+                "Role",
+                AssumeRolePolicyDocument=get_ecs_task_assumerole_policy(),
+                Path="/",
+            )
+        )
+
+        self.add_output("RoleName", self.role.Ref())
+        self.add_output("RoleArn", self.role.GetAtt("Arn"))
+        self.add_output("RoleId", self.role.GetAtt("RoleId"))
+
+    def generate_policy_document(self):
+        return None
+
+    def create_policy(self):
+        t = self.template
+
+        policy_doc = self.generate_policy_document()
+        if not policy_doc:
+            return
+
+        self.policy = t.add_resource(
+            iam.ManagedPolicy(
+                "ManagedPolicy",
+                PolicyDocument=self.generate_policy(),
+                Roles=[self.role.Ref()],
+            )
+        )
+
+        self.add_output("ManagedPolicyArn", self.policy.Ref())
+
+    def generate_container_definition(self):
+        return ecs.ContainerDefinition(
+            Command=self.command,
+            Cpu=self.cpu,
+            Environment=self.environment,
+            Essential=True,
+            Image=self.image,
+            LogConfiguration=self.log_configuration,
+            Memory=self.memory,
+            Name=self.service_name,
+        )
+
+    def create_task_definition(self):
+        t = self.template
+
+        self.task_definition = t.add_resource(
+            ecs.TaskDefinition(
+                "TaskDefinition",
+                Cpu=str(self.cpu),
+                Family=self.service_name,
+                Memory=str(self.memory),
+                TaskRoleArn=self.role.GetAtt("Arn"),
+                ContainerDefinitions=[self.generate_container_definition()]
+            )
+        )
+
+        self.add_output("TaskDefinitionArn", self.task_definition.Ref())
+
+    def create_service(self):
+        t = self.template
+        self.service = t.add_resource(
+            ecs.Service(
+                "Service",
+                Cluster=self.cluster,
+                DesiredCount=self.count,
+                LaunchType="EC2",
+                ServiceName=self.service_name,
+                TaskDefinition=self.task_definition.Ref(),
+            )
+        )
+
+        self.add_output("ServiceArn", self.service.Ref())
+        self.add_output("ServiceName", self.service.GetAtt("Name"))
+
+    def create_template(self):
+        self.create_role()
+        self.create_policy()
+        self.create_task_definition()
+        self.create_service()

tests/fixtures/blueprints/ecs__simple_ecs_service.json

@@ -0,0 +1,118 @@
+{
+    "Outputs": {
+        "RoleArn": {
+            "Value": {
+                "Fn::GetAtt": [
+                    "Role", 
+                    "Arn"
+                ]
+            }
+        }, 
+        "RoleId": {
+            "Value": {
+                "Fn::GetAtt": [
+                    "Role", 
+                    "RoleId"
+                ]
+            }
+        }, 
+        "RoleName": {
+            "Value": {
+                "Ref": "Role"
+            }
+        }, 
+        "ServiceArn": {
+            "Value": {
+                "Ref": "Service"
+            }
+        }, 
+        "ServiceName": {
+            "Value": {
+                "Fn::GetAtt": [
+                    "Service", 
+                    "Name"
+                ]
+            }
+        }, 
+        "TaskDefinitionArn": {
+            "Value": {
+                "Ref": "TaskDefinition"
+            }
+        }
+    }, 
+    "Resources": {
+        "Role": {
+            "Properties": {
+                "AssumeRolePolicyDocument": {
+                    "Statement": [
+                        {
+                            "Action": [
+                                "sts:AssumeRole"
+                            ], 
+                            "Effect": "Allow", 
+                            "Principal": {
+                                "Service": [
+                                    "ecs-tasks.amazonaws.com"
+                                ]
+                            }
+                        }
+                    ]
+                }, 
+                "Path": "/"
+            }, 
+            "Type": "AWS::IAM::Role"
+        }, 
+        "Service": {
+            "Properties": {
+                "Cluster": "fake-fargate-cluster", 
+                "DesiredCount": 3, 
+                "LaunchType": "EC2", 
+                "ServiceName": "WorkerService", 
+                "TaskDefinition": {
+                    "Ref": "TaskDefinition"
+                }
+            }, 
+            "Type": "AWS::ECS::Service"
+        }, 
+        "TaskDefinition": {
+            "Properties": {
+                "ContainerDefinitions": [
+                    {
+                        "Command": [
+                            "/bin/run", 
+                            "--args 1"
+                        ], 
+                        "Cpu": 1024, 
+                        "Environment": [
+                            {
+                                "Name": "DEBUG", 
+                                "Value": "false"
+                            }, 
+                            {
+                                "Name": "DATABASE_URL", 
+                                "Value": "sql://fake_db/fake_db"
+                            }
+                        ], 
+                        "Essential": "true", 
+                        "Image": "fake_repo/image:12345", 
+                        "LogConfiguration": {
+                            "Ref": "AWS::NoValue"
+                        }, 
+                        "Memory": 2048, 
+                        "Name": "WorkerService"
+                    }
+                ], 
+                "Cpu": "1024", 
+                "Family": "WorkerService", 
+                "Memory": "2048", 
+                "TaskRoleArn": {
+                    "Fn::GetAtt": [
+                        "Role", 
+                        "Arn"
+                    ]
+                }
+            }, 
+            "Type": "AWS::ECS::TaskDefinition"
+        }
+    }
+}

tests/test_ecs.py

@@ -1,6 +1,10 @@
 from stacker.context import Context
 from stacker.variables import Variable
-from stacker_blueprints.ecs import Cluster, SimpleFargateService
+from stacker_blueprints.ecs import (
+    Cluster,
+    SimpleFargateService,
+    SimpleECSService,
+)
 from stacker.blueprints.testutil import BlueprintTestCase
 
 
@@ -49,3 +53,37 @@ def test_ecs_simple_fargate_service(self):
         bp.resolve_variables(self.generate_variables())
         bp.create_template()
         self.assertRenderedBlueprint(bp)
+
+
+class TestSimpleECSService(BlueprintTestCase):
+    def setUp(self):
+        self.common_variables = {
+            "ServiceName": "WorkerService",
+            "Image": "fake_repo/image:12345",
+            "Command": ["/bin/run", "--args 1"],
+            "Cluster": "fake-fargate-cluster",
+            "CPU": 1024,
+            "Memory": 2048,
+            "Count": 3,
+            "Environment": {
+                "DATABASE_URL": "sql://fake_db/fake_db",
+                "DEBUG": "false",
+            },
+        }
+
+        self.ctx = Context({'namespace': 'test', 'environment': 'test'})
+
+    def create_blueprint(self, name):
+        return SimpleECSService(name, self.ctx)
+
+    def generate_variables(self, variable_dict=None):
+        variable_dict = variable_dict or {}
+        self.common_variables.update(variable_dict)
+
+        return [Variable(k, v) for k, v in self.common_variables.items()]
+
+    def test_ecs_simple_fargate_service(self):
+        bp = self.create_blueprint("ecs__simple_ecs_service")
+        bp.resolve_variables(self.generate_variables())
+        bp.create_template()
+        self.assertRenderedBlueprint(bp)