cartography 0.105.0__py3-none-any.whl → 0.106.0rc1__py3-none-any.whl

cartography/intel/kubernetes/util.py

@@ -1,11 +1,16 @@
+import logging
 from datetime import datetime
-from typing import List
-from typing import Union
+from typing import Any
+from typing import Callable
 
 from kubernetes import config
 from kubernetes.client import ApiClient
 from kubernetes.client import CoreV1Api
 from kubernetes.client import NetworkingV1Api
+from kubernetes.client import VersionApi
+from kubernetes.client.exceptions import ApiException
+
+logger = logging.getLogger(__name__)
 
 
 class KubernetesContextNotFound(Exception):
@@ -13,39 +18,145 @@ class KubernetesContextNotFound(Exception):
 
 
 class K8CoreApiClient(CoreV1Api):
-    def __init__(self, name: str, api_client: ApiClient = None) -> None:
+    def __init__(
+        self,
+        name: str,
+        config_file: str,
+        api_client: ApiClient | None = None,
+    ) -> None:
         self.name = name
         if not api_client:
-            api_client = config.new_client_from_config(context=name)
+            api_client = config.new_client_from_config(
+                context=name, config_file=config_file
+            )
         super().__init__(api_client=api_client)
 
 
 class K8NetworkingApiClient(NetworkingV1Api):
-    def __init__(self, name: str, api_client: ApiClient = None) -> None:
+    def __init__(
+        self,
+        name: str,
+        config_file: str,
+        api_client: ApiClient | None = None,
+    ) -> None:
+        self.name = name
+        if not api_client:
+            api_client = config.new_client_from_config(
+                context=name, config_file=config_file
+            )
+        super().__init__(api_client=api_client)
+
+
+class K8VersionApiClient(VersionApi):
+    def __init__(
+        self,
+        name: str,
+        config_file: str,
+        api_client: ApiClient | None = None,
+    ) -> None:
         self.name = name
         if not api_client:
-            api_client = config.new_client_from_config(context=name)
+            api_client = config.new_client_from_config(
+                context=name, config_file=config_file
+            )
         super().__init__(api_client=api_client)
 
 
 class K8sClient:
-    def __init__(self, name: str) -> None:
+    def __init__(
+        self,
+        name: str,
+        config_file: str,
+        external_id: str | None = None,
+    ) -> None:
         self.name = name
-        self.core = K8CoreApiClient(self.name)
-        self.networking = K8NetworkingApiClient(self.name)
+        self.config_file = config_file
+        self.external_id = external_id
+        self.core = K8CoreApiClient(self.name, self.config_file)
+        self.networking = K8NetworkingApiClient(self.name, self.config_file)
+        self.version = K8VersionApiClient(self.name, self.config_file)
 
 
-def get_k8s_clients(kubeconfig: str) -> List[K8sClient]:
+def get_k8s_clients(kubeconfig: str) -> list[K8sClient]:
+    # returns a tuple of (all contexts, current context)
     contexts, _ = config.list_kube_config_contexts(kubeconfig)
     if not contexts:
         raise KubernetesContextNotFound("No context found in kubeconfig.")
-    clients = list()
+
+    clients = []
     for context in contexts:
-        clients.append(K8sClient(context["name"]))
+        clients.append(
+            K8sClient(
+                context["name"],
+                kubeconfig,
+                external_id=context["context"].get("cluster"),
+            ),
+        )
     return clients
 
 
-def get_epoch(date: datetime) -> Union[int, None]:
+def get_epoch(date: datetime | None) -> int | None:
     if date:
-        return int(date.strftime("%s"))
+        return int(date.timestamp())
     return None
+
+
+def k8s_paginate(
+    list_func: Callable,
+    **kwargs: Any,
+) -> list[dict[str, Any]]:
+    """
+    Handles pagination for a Kubernetes API call.
+
+    :param list_func: The list function to call (e.g. client.core.list_pod_for_all_namespaces)
+    :param kwargs: Keyword arguments to pass to the list function (e.g. limit=100)
+    :return: A list of all resources returned by the list function
+    """
+    all_resources = []
+    continue_token = None
+    limit = kwargs.pop("limit", 100)
+    function_name = list_func.__name__
+
+    logger.debug(f"Starting pagination for {function_name} with limit {limit}.")
+
+    while True:
+        try:
+            if continue_token:
+                response = list_func(limit=limit, _continue=continue_token, **kwargs)
+            else:
+                response = list_func(limit=limit, **kwargs)
+
+            # Check if items exists on the response
+            if not hasattr(response, "items"):
+                logger.warning(
+                    f"Response from {function_name} does not contain 'items' attribute."
+                )
+                break
+
+            items_count = len(response.items)
+            all_resources.extend(response.items)
+
+            logger.debug(f"Retrieved {items_count} {function_name} resources")
+
+            # Check if metadata exists on the response
+            if not hasattr(response, "metadata"):
+                logger.warning(
+                    f"Response from {function_name} does not contain 'metadata' attribute."
+                )
+                break
+
+            continue_token = response.metadata._continue
+            if not continue_token:
+                logger.debug(f"No more {function_name} resources to retrieve.")
+                break
+
+        except ApiException as e:
+            logger.error(
+                f"Kubernetes API error retrieving {function_name} resources. {e}: {e.status} - {e.reason}"
+            )
+            break
+
+    logger.debug(
+        f"Completed pagination for {function_name}: retrieved {len(all_resources)} resources"
+    )
+    return all_resources

cartography/models/aws/ecs/clusters.py

@@ -0,0 +1,64 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class ECSClusterNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef("clusterArn")
+    arn: PropertyRef = PropertyRef("clusterArn", extra_index=True)
+    name: PropertyRef = PropertyRef("clusterName")
+    region: PropertyRef = PropertyRef("Region", set_in_kwargs=True)
+    status: PropertyRef = PropertyRef("status")
+    ecc_kms_key_id: PropertyRef = PropertyRef("ecc_kms_key_id")
+    ecc_logging: PropertyRef = PropertyRef("ecc_logging")
+    ecc_log_configuration_cloud_watch_log_group_name: PropertyRef = PropertyRef(
+        "ecc_log_configuration_cloud_watch_log_group_name"
+    )
+    ecc_log_configuration_cloud_watch_encryption_enabled: PropertyRef = PropertyRef(
+        "ecc_log_configuration_cloud_watch_encryption_enabled"
+    )
+    ecc_log_configuration_s3_bucket_name: PropertyRef = PropertyRef(
+        "ecc_log_configuration_s3_bucket_name"
+    )
+    ecc_log_configuration_s3_encryption_enabled: PropertyRef = PropertyRef(
+        "ecc_log_configuration_s3_encryption_enabled"
+    )
+    ecc_log_configuration_s3_key_prefix: PropertyRef = PropertyRef(
+        "ecc_log_configuration_s3_key_prefix"
+    )
+    capacity_providers: PropertyRef = PropertyRef("capacityProviders")
+    attachments_status: PropertyRef = PropertyRef("attachmentsStatus")
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSClusterToAWSAccountRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSClusterToAWSAccountRel(CartographyRelSchema):
+    target_node_label: str = "AWSAccount"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("AWS_ID", set_in_kwargs=True)}
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: ECSClusterToAWSAccountRelProperties = (
+        ECSClusterToAWSAccountRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class ECSClusterSchema(CartographyNodeSchema):
+    label: str = "ECSCluster"
+    properties: ECSClusterNodeProperties = ECSClusterNodeProperties()
+    sub_resource_relationship: ECSClusterToAWSAccountRel = ECSClusterToAWSAccountRel()

cartography/models/aws/ecs/container_definitions.py

@@ -0,0 +1,93 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import OtherRelationships
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class ECSContainerDefinitionNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef("id")
+    task_definition_arn: PropertyRef = PropertyRef("_taskDefinitionArn")
+    name: PropertyRef = PropertyRef("name")
+    image: PropertyRef = PropertyRef("image")
+    cpu: PropertyRef = PropertyRef("cpu")
+    memory: PropertyRef = PropertyRef("memory")
+    memory_reservation: PropertyRef = PropertyRef("memoryReservation")
+    links: PropertyRef = PropertyRef("links")
+    essential: PropertyRef = PropertyRef("essential")
+    entry_point: PropertyRef = PropertyRef("entryPoint")
+    command: PropertyRef = PropertyRef("command")
+    start_timeout: PropertyRef = PropertyRef("startTimeout")
+    stop_timeout: PropertyRef = PropertyRef("stop_timeout")
+    hostname: PropertyRef = PropertyRef("hostname")
+    user: PropertyRef = PropertyRef("user")
+    working_directory: PropertyRef = PropertyRef("workingDirectory")
+    disable_networking: PropertyRef = PropertyRef("disableNetworking")
+    privileged: PropertyRef = PropertyRef("privileged")
+    readonly_root_filesystem: PropertyRef = PropertyRef("readonlyRootFilesystem")
+    dns_servers: PropertyRef = PropertyRef("dnsServers")
+    dns_search_domains: PropertyRef = PropertyRef("dnsSearchDomains")
+    docker_security_options: PropertyRef = PropertyRef("dockerSecurityOptions")
+    interactive: PropertyRef = PropertyRef("interactive")
+    pseudo_terminal: PropertyRef = PropertyRef("pseudoTerminal")
+    region: PropertyRef = PropertyRef("Region", set_in_kwargs=True)
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSContainerDefinitionToAWSAccountRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSContainerDefinitionToAWSAccountRel(CartographyRelSchema):
+    target_node_label: str = "AWSAccount"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("AWS_ID", set_in_kwargs=True)}
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: ECSContainerDefinitionToAWSAccountRelProperties = (
+        ECSContainerDefinitionToAWSAccountRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class ECSContainerDefinitionToTaskDefinitionRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSContainerDefinitionToTaskDefinitionRel(CartographyRelSchema):
+    target_node_label: str = "ECSTaskDefinition"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("_taskDefinitionArn")}
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "HAS_CONTAINER_DEFINITION"
+    properties: ECSContainerDefinitionToTaskDefinitionRelProperties = (
+        ECSContainerDefinitionToTaskDefinitionRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class ECSContainerDefinitionSchema(CartographyNodeSchema):
+    label: str = "ECSContainerDefinition"
+    properties: ECSContainerDefinitionNodeProperties = (
+        ECSContainerDefinitionNodeProperties()
+    )
+    sub_resource_relationship: ECSContainerDefinitionToAWSAccountRel = (
+        ECSContainerDefinitionToAWSAccountRel()
+    )
+    other_relationships: OtherRelationships = OtherRelationships(
+        [
+            ECSContainerDefinitionToTaskDefinitionRel(),
+        ]
+    )

cartography/models/aws/ecs/container_instances.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import OtherRelationships
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class ECSContainerInstanceNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef("containerInstanceArn")
+    arn: PropertyRef = PropertyRef("containerInstanceArn", extra_index=True)
+    ec2_instance_id: PropertyRef = PropertyRef("ec2InstanceId")
+    capacity_provider_name: PropertyRef = PropertyRef("capacityProviderName")
+    version: PropertyRef = PropertyRef("version")
+    version_info_agent_version: PropertyRef = PropertyRef("versionInfo.agentVersion")
+    version_info_agent_hash: PropertyRef = PropertyRef("versionInfo.agentHash")
+    version_info_agent_docker_version: PropertyRef = PropertyRef(
+        "versionInfo.dockerVersion"
+    )
+    status: PropertyRef = PropertyRef("status")
+    status_reason: PropertyRef = PropertyRef("statusReason")
+    agent_connected: PropertyRef = PropertyRef("agentConnected")
+    agent_update_status: PropertyRef = PropertyRef("agentUpdateStatus")
+    registered_at: PropertyRef = PropertyRef("registeredAt")
+    region: PropertyRef = PropertyRef("Region", set_in_kwargs=True)
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSContainerInstanceToAWSAccountRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSContainerInstanceToAWSAccountRel(CartographyRelSchema):
+    target_node_label: str = "AWSAccount"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("AWS_ID", set_in_kwargs=True)}
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: ECSContainerInstanceToAWSAccountRelProperties = (
+        ECSContainerInstanceToAWSAccountRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class ECSContainerInstanceToECSClusterRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSContainerInstanceToECSClusterRel(CartographyRelSchema):
+    target_node_label: str = "ECSCluster"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("ClusterArn", set_in_kwargs=True)}
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "HAS_CONTAINER_INSTANCE"
+    properties: ECSContainerInstanceToECSClusterRelProperties = (
+        ECSContainerInstanceToECSClusterRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class ECSContainerInstanceSchema(CartographyNodeSchema):
+    label: str = "ECSContainerInstance"
+    properties: ECSContainerInstanceNodeProperties = (
+        ECSContainerInstanceNodeProperties()
+    )
+    sub_resource_relationship: ECSContainerInstanceToAWSAccountRel = (
+        ECSContainerInstanceToAWSAccountRel()
+    )
+    other_relationships: OtherRelationships = OtherRelationships(
+        [
+            ECSContainerInstanceToECSClusterRel(),
+        ]
+    )

cartography/models/aws/ecs/containers.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import OtherRelationships
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class ECSContainerNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef("containerArn")
+    arn: PropertyRef = PropertyRef("containerArn", extra_index=True)
+    task_arn: PropertyRef = PropertyRef("taskArn")
+    name: PropertyRef = PropertyRef("name")
+    image: PropertyRef = PropertyRef("image")
+    image_digest: PropertyRef = PropertyRef("imageDigest")
+    runtime_id: PropertyRef = PropertyRef("runtimeId")
+    last_status: PropertyRef = PropertyRef("lastStatus")
+    exit_code: PropertyRef = PropertyRef("exitCode")
+    reason: PropertyRef = PropertyRef("reason")
+    health_status: PropertyRef = PropertyRef("healthStatus")
+    cpu: PropertyRef = PropertyRef("cpu")
+    memory: PropertyRef = PropertyRef("memory")
+    memory_reservation: PropertyRef = PropertyRef("memoryReservation")
+    gpu_ids: PropertyRef = PropertyRef("gpuIds")
+    region: PropertyRef = PropertyRef("Region", set_in_kwargs=True)
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSContainerToAWSAccountRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSContainerToAWSAccountRel(CartographyRelSchema):
+    target_node_label: str = "AWSAccount"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("AWS_ID", set_in_kwargs=True)}
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: ECSContainerToAWSAccountRelProperties = (
+        ECSContainerToAWSAccountRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class ECSContainerToTaskRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSContainerToTaskRel(CartographyRelSchema):
+    target_node_label: str = "ECSTask"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("taskArn")}
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "HAS_CONTAINER"
+    properties: ECSContainerToTaskRelProperties = ECSContainerToTaskRelProperties()
+
+
+@dataclass(frozen=True)
+class ECSContainerSchema(CartographyNodeSchema):
+    label: str = "ECSContainer"
+    properties: ECSContainerNodeProperties = ECSContainerNodeProperties()
+    sub_resource_relationship: ECSContainerToAWSAccountRel = (
+        ECSContainerToAWSAccountRel()
+    )
+    other_relationships: OtherRelationships = OtherRelationships(
+        [
+            ECSContainerToTaskRel(),
+        ]
+    )

cartography/models/aws/ecs/services.py

@@ -0,0 +1,117 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import OtherRelationships
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class ECSServiceNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef("serviceArn")
+    arn: PropertyRef = PropertyRef("serviceArn", extra_index=True)
+    name: PropertyRef = PropertyRef("serviceName")
+    cluster_arn: PropertyRef = PropertyRef("clusterArn")
+    status: PropertyRef = PropertyRef("status")
+    desired_count: PropertyRef = PropertyRef("desiredCount")
+    running_count: PropertyRef = PropertyRef("runningCount")
+    pending_count: PropertyRef = PropertyRef("pendingCount")
+    launch_type: PropertyRef = PropertyRef("launchType")
+    platform_version: PropertyRef = PropertyRef("platformVersion")
+    platform_family: PropertyRef = PropertyRef("platformFamily")
+    task_definition: PropertyRef = PropertyRef("taskDefinition")
+    deployment_config_circuit_breaker_enable: PropertyRef = PropertyRef(
+        "deploymentConfiguration.deploymentCircuitBreaker.enable"
+    )
+    deployment_config_circuit_breaker_rollback: PropertyRef = PropertyRef(
+        "deploymentConfiguration.deploymentCircuitBreaker.rollback"
+    )
+    deployment_config_maximum_percent: PropertyRef = PropertyRef(
+        "deploymentConfiguration.maximumPercent"
+    )
+    deployment_config_minimum_healthy_percent: PropertyRef = PropertyRef(
+        "deploymentConfiguration.minimumHealthyPercent"
+    )
+    role_arn: PropertyRef = PropertyRef("roleArn")
+    created_at: PropertyRef = PropertyRef("createdAt")
+    health_check_grace_period_seconds: PropertyRef = PropertyRef(
+        "healthCheckGracePeriodSeconds"
+    )
+    created_by: PropertyRef = PropertyRef("createdBy")
+    enable_ecs_managed_tags: PropertyRef = PropertyRef("enableECSManagedTags")
+    propagate_tags: PropertyRef = PropertyRef("propagateTags")
+    enable_execute_command: PropertyRef = PropertyRef("enableExecuteCommand")
+    region: PropertyRef = PropertyRef("Region", set_in_kwargs=True)
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSServiceToECSClusterRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSServiceToECSClusterRel(CartographyRelSchema):
+    target_node_label: str = "ECSCluster"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("ClusterArn", set_in_kwargs=True)}
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "HAS_SERVICE"
+    properties: ECSServiceToECSClusterRelProperties = (
+        ECSServiceToECSClusterRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class ECSServiceToTaskDefinitionRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSServiceToTaskDefinitionRel(CartographyRelSchema):
+    target_node_label: str = "ECSTaskDefinition"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("taskDefinition")}
+    )
+    direction: LinkDirection = LinkDirection.OUTWARD
+    rel_label: str = "HAS_TASK_DEFINITION"
+    properties: ECSServiceToTaskDefinitionRelProperties = (
+        ECSServiceToTaskDefinitionRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class ECSServiceToAWSAccountRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class ECSServiceToAWSAccountRel(CartographyRelSchema):
+    target_node_label: str = "AWSAccount"
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {"id": PropertyRef("AWS_ID", set_in_kwargs=True)}
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: ECSServiceToAWSAccountRelProperties = (
+        ECSServiceToAWSAccountRelProperties()
+    )
+
+
+@dataclass(frozen=True)
+class ECSServiceSchema(CartographyNodeSchema):
+    label: str = "ECSService"
+    properties: ECSServiceNodeProperties = ECSServiceNodeProperties()
+    sub_resource_relationship: ECSServiceToAWSAccountRel = ECSServiceToAWSAccountRel()
+    other_relationships: OtherRelationships = OtherRelationships(
+        [
+            ECSServiceToECSClusterRel(),
+            ECSServiceToTaskDefinitionRel(),
+        ]
+    )