Eveyrthing should be working

moto/ecs/models.py

@@ -265,6 +265,11 @@ def response_object(self) -> Dict[str, Any]:  # type: ignore[misc]
         if not response_object["memory"]:
             del response_object["memory"]
 
+        if hasattr(self, "task_role_arn"):
+            response_object["taskRoleArn"] = self.task_role_arn
+        if hasattr(self, "execution_role_arn"):
+            response_object["executionRoleArn"] = self.execution_role_arn
+
         return {
             "taskDefinition": response_object,
             "tags": response_object.get("tags", []),

moto/ecs/responses.py

@@ -250,35 +250,36 @@ def stop_task(self) -> str:
         return json.dumps({"task": task.response_object()})
 
     def create_service(self) -> str:
-        cluster_str = self._get_param("cluster", "default")
+        cluster = self._get_param("cluster", "default")
         service_name = self._get_param("serviceName")
-        task_definition_str = self._get_param("taskDefinition")
-        desired_count = self._get_int_param("desiredCount")
+        task_definition = self._get_param("taskDefinition")
+        desired_count = self._get_int_param("desiredCount", 1)
         load_balancers = self._get_param("loadBalancers")
         scheduling_strategy = self._get_param("schedulingStrategy")
-        service_registries = self._get_param("serviceRegistries")
         tags = self._get_param("tags")
         deployment_controller = self._get_param("deploymentController")
         launch_type = self._get_param("launchType")
+        service_registries = self._get_param("serviceRegistries")
         platform_version = self._get_param("platformVersion")
-        propagate_tags = self._get_param("propagateTags") or "NONE"
+        propagate_tags = self._get_param("propagateTags")
         network_configuration = self._get_param("networkConfiguration")
-        role_arn = self._get_param("roleArn")
+        role = self._get_param("role")
+
         service = self.ecs_backend.create_service(
-            cluster_str,
+            cluster,
             service_name,
             desired_count,
-            task_definition_str,
-            load_balancers,
-            scheduling_strategy,
-            tags,
-            deployment_controller,
-            launch_type,
-            network_configuration=network_configuration,
+            task_definition_str=task_definition,
+            load_balancers=load_balancers,
+            scheduling_strategy=scheduling_strategy,
+            tags=tags,
+            deployment_controller=deployment_controller,
+            launch_type=launch_type,
             service_registries=service_registries,
             platform_version=platform_version,
             propagate_tags=propagate_tags,
-            role_arn=role_arn,
+            network_configuration=network_configuration,
+            role_arn=role,
         )
         return json.dumps({"service": service.response_object})
 

tests/test_ecs/test_ecs_boto3.py

@@ -3903,3 +3903,82 @@ def test_service_exceptions(net_config, error_message):
     assert ex.response["ResponseMetadata"]["HTTPStatusCode"] == 400
     assert ex.response["Error"]["Code"] == "InvalidParameterException"
     assert ex.response["Error"]["Message"] == error_message
+
+
+@mock_aws
+def test_create_service_with_role_arn():
+    client = boto3.client("ecs", region_name=ECS_REGION)
+    cluster_name = "test_ecs_cluster"
+    service_name = "test_ecs_service"
+    task_definition_family = "test_ecs_task"
+    role_arn = "arn:aws:iam::123456789012:role/test-role"
+
+    client.create_cluster(clusterName=cluster_name)
+
+    client.register_task_definition(
+        family=task_definition_family,
+        containerDefinitions=[
+            {
+                "name": "hello_world",
+                "image": "docker/hello-world:latest",
+                "cpu": 1024,
+                "memory": 400,
+                "essential": True,
+            }
+        ],
+    )
+
+    response = client.create_service(
+        cluster=cluster_name,
+        serviceName=service_name,
+        taskDefinition=task_definition_family,
+        desiredCount=2,
+        role=role_arn,
+    )
+
+    assert response["service"]["roleArn"] == role_arn
+
+    describe_response = client.describe_services(
+        cluster=cluster_name, services=[service_name]
+    )
+    assert describe_response["services"][0]["roleArn"] == role_arn
+
+
+@mock_aws
+def test_task_definition_with_role_arns():
+    client = boto3.client("ecs", region_name=ECS_REGION)
+    task_definition_family = "test_ecs_task"
+    task_role_arn = "arn:aws:iam::123456789012:role/test-task-role"
+    execution_role_arn = "arn:aws:iam::123456789012:role/test-execution-role"
+
+    response = client.register_task_definition(
+        family=task_definition_family,
+        containerDefinitions=[
+            {
+                "name": "hello_world",
+                "image": "docker/hello-world:latest",
+                "cpu": 1024,
+                "memory": 400,
+                "essential": True,
+            }
+        ],
+        taskRoleArn=task_role_arn,
+        executionRoleArn=execution_role_arn,
+    )
+
+    assert response["taskDefinition"]["taskRoleArn"] == task_role_arn
+    assert response["taskDefinition"]["executionRoleArn"] == execution_role_arn
+
+    describe_response = client.describe_task_definition(
+        taskDefinition=task_definition_family
+    )
+    assert describe_response["taskDefinition"]["taskRoleArn"] == task_role_arn
+    assert describe_response["taskDefinition"]["executionRoleArn"] == execution_role_arn
+
+    list_response = client.list_task_definitions(familyPrefix=task_definition_family)
+    task_def_arn = list_response["taskDefinitionArns"][0]
+    describe_from_list = client.describe_task_definition(taskDefinition=task_def_arn)
+    assert describe_from_list["taskDefinition"]["taskRoleArn"] == task_role_arn
+    assert (
+        describe_from_list["taskDefinition"]["executionRoleArn"] == execution_role_arn
+    )