Amazon Elastic Container Service (ECS)

AWS::ECS::Cluster

The following example demonstrates how to ingest your AWS ECS clusters to Port.

ECS Cluster supported actions

The table below summarizes the available actions for ingesting Amazon ECS Cluster resources in Port:

Action	Description	Type	Required AWS Permission
DescribeClustersAction	Discover ECS clusters and retrieve detailed configuration data.	Default	ecs:ListClusters, ecs:DescribeClusters

All properties available by default

ECS clusters expose their key properties via the default DescribeClusters action.

You can use the following Port blueprint definitions and integration configuration:

ECS Cluster blueprint (click to expand)

{
  "identifier": "ecsCluster",
  "description": "This blueprint represents an AWS ECS cluster in our software catalog",
  "title": "ECS cluster",
  "icon": "AWS",
  "schema": {
    "properties": {
      "status": {
        "type": "string",
        "title": "Status"
      },
      "runningTasksCount": {
        "type": "number",
        "title": "Running tasks count"
      },
      "activeServicesCount": {
        "type": "number",
        "title": "Active services count"
      },
      "pendingTasksCount": {
        "type": "number",
        "title": "Pending tasks count"
      },
      "registeredContainerInstancesCount": {
        "type": "number",
        "title": "Registered container instances count"
      },
      "capacityProviders": {
        "type": "array",
        "title": "Capacity providers"
      },
      "clusterArn": {
        "type": "string",
        "title": "Cluster ARN"
      },
      "tags": {
        "type": "array",
        "title": "Tags",
        "items": {
          "type": "object",
          "properties": {
            "Key": {
              "type": "string"
            },
            "Value": {
              "type": "string"
            }
          }
        }
      }
    },
    "required": []
  },
  "mirrorProperties": {},
  "calculationProperties": {},
  "aggregationProperties": {},
  "relations": {
    "account": {
      "title": "Account",
      "target": "awsAccount",
      "required": true,
      "many": false
    }
  }
}

ECS Cluster mapping configuration (click to expand)

resources:
  - kind: AWS::ECS::Cluster
    selector:
      query: 'true'
      # includeActions: No optional actions available for ECS clusters
      # All properties are included by default via DescribeClustersAction
    port:
      entity:
        mappings:
          identifier: .Properties.ClusterArn
          title: .Properties.ClusterName
          blueprint: '"ecsCluster"'
          properties:
            status: .Properties.Status
            runningTasksCount: .Properties.RunningTasksCount
            activeServicesCount: .Properties.ActiveServicesCount
            pendingTasksCount: .Properties.PendingTasksCount
            registeredContainerInstancesCount: .Properties.RegisteredContainerInstancesCount
            capacityProviders: .Properties.CapacityProviders
            clusterArn: .Properties.ClusterArn
            tags: .Properties.Tags
          relations:
            account: .__ExtraContext.AccountId

AWS::ECS::Service

The following example demonstrates how to ingest your AWS ECS services to Port.

ECS Service supported actions

The table below summarizes the available actions for ingesting Amazon ECS Service resources in Port:

Action	Description	Type	Required AWS Permission
DescribeServicesAction	Discover ECS services within your clusters and retrieve detailed configuration data.	Default	ecs:ListServices, ecs:DescribeServices

Optional Properties Note

Properties of optional actions will not appear in the response unless you explicitly include the action that provides them in your configuration.

You can use the following Port blueprint definitions and integration configuration:

ECS Service blueprint (click to expand)

{
  "identifier": "ecsService",
  "title": "ECS Service",
  "icon": "AWS",
  "schema": {
    "properties": {
      "serviceName": {
        "type": "string",
        "title": "Service Name",
        "description": "The name of the ECS service"
      },
      "serviceArn": {
        "type": "string",
        "title": "ARN",
        "description": "The Amazon Resource Name (ARN) of the service"
      },
      "clusterArn": {
        "type": "string",
        "title": "Cluster ARN",
        "description": "The ARN of the cluster that hosts the service"
      },
      "taskDefinition": {
        "type": "string",
        "title": "Task Definition",
        "description": "The ARN of the task definition associated with the service"
      },
      "desiredCount": {
        "type": "number",
        "title": "Desired Count",
        "description": "The desired number of tasks for the service"
      },
      "runningCount": {
        "type": "number",
        "title": "Running Count",
        "description": "The number of tasks that are currently running"
      },
      "launchType": {
        "type": "string",
        "title": "Launch Type",
        "description": "The launch type of the service",
        "enum": ["EC2", "FARGATE", "EXTERNAL"]
      },
      "status": {
        "type": "string",
        "title": "Status",
        "description": "The current status of the service",
        "enum": ["ACTIVE", "DRAINING", "INACTIVE"]
      }
    },
    "required": []
  },
  "mirrorProperties": {},
  "calculationProperties": {},
  "aggregationProperties": {},
  "relations": {
    "account": {
      "title": "Account",
      "target": "awsAccount",
      "required": false,
      "many": false
    },
    "cluster": {
      "title": "Cluster",
      "target": "ecsCluster",
      "required": false,
      "many": false
    }
  }
}

ECS Service mapping configuration (click to expand)

resources:
  - kind: AWS::ECS::Service
    selector:
      query: 'true'
    port:
      entity:
        mappings:
          identifier: .Properties.ServiceArn
          title: .Properties.ServiceName
          blueprint: '"ecsService"'
          properties:
            serviceName: .Properties.ServiceName
            serviceArn: .Properties.ServiceArn
            clusterArn: .Properties.ClusterArn
            taskDefinition: .Properties.TaskDefinition
            desiredCount: .Properties.DesiredCount
            runningCount: .Properties.RunningCount
            launchType: .Properties.LaunchType
            status: .Properties.Status
          relations:
            account: .__ExtraContext.AccountId
            cluster: .Properties.ClusterArn

AWS::ECS::TaskDefinition

The following example demonstrates how to ingest your AWS ECS task definitions to Port.

ECS Task Definition supported actions

The table below summarizes the available actions for ingesting Amazon ECS Task Definition resources in Port:

Action	Description	Type	Required AWS Permission
ListTaskDefinitionsAction	List all active task definition ARNs in the account.	Default	ecs:ListTaskDefinitions
DescribeTaskDefinitionsAction	Fetch full container configuration details for each task definition.	Default	ecs:DescribeTaskDefinition

All properties available by default

ECS task definitions expose all key properties via the default ListTaskDefinitions and DescribeTaskDefinitions actions.

You can use the following Port blueprint definitions and integration configuration:

ECS Task Definition blueprint (click to expand)

[
  {
    "identifier": "ecsTaskDefinition",
    "title": "ECS Task Definition",
    "icon": "AWS",
    "schema": {
      "properties": {
        "taskDefinitionArn": {
          "type": "string",
          "title": "Task Definition ARN",
          "description": "The full ARN of the task definition"
        },
        "family": {
          "type": "string",
          "title": "Family",
          "description": "The family name of the task definition"
        },
        "revision": {
          "type": "number",
          "title": "Revision",
          "description": "The revision number of the task definition"
        },
        "status": {
          "type": "string",
          "title": "Status",
          "description": "The status of the task definition",
          "enum": ["ACTIVE", "INACTIVE", "DELETE_IN_PROGRESS"]
        },
        "containerDefinitions": {
          "type": "array",
          "title": "Container Definitions",
          "description": "The container definitions that describe the containers in the task",
          "items": {
            "type": "object"
          }
        },
        "cpu": {
          "type": "string",
          "title": "CPU",
          "description": "The number of CPU units used by the task (e.g. 256, 512, 1024)"
        },
        "memory": {
          "type": "string",
          "title": "Memory",
          "description": "The amount of memory (in MiB) used by the task (e.g. 512, 1024, 2048)"
        },
        "networkMode": {
          "type": "string",
          "title": "Network Mode",
          "description": "The Docker networking mode to use for the containers",
          "enum": ["bridge", "host", "awsvpc", "none"]
        },
        "requiresCompatibilities": {
          "type": "array",
          "title": "Requires Compatibilities",
          "description": "The task launch types the task definition was validated against",
          "items": {
            "type": "string"
          }
        },
        "taskRoleArn": {
          "type": "string",
          "title": "Task Role ARN",
          "description": "The ARN of the IAM role that grants containers permission to call AWS APIs"
        },
        "executionRoleArn": {
          "type": "string",
          "title": "Execution Role ARN",
          "description": "The ARN of the task execution IAM role"
        },
        "volumes": {
          "type": "array",
          "title": "Volumes",
          "description": "The list of data volume definitions for the task",
          "items": {
            "type": "object"
          }
        },
        "placementConstraints": {
          "type": "array",
          "title": "Placement Constraints",
          "description": "The placement constraint objects to use for tasks",
          "items": {
            "type": "object"
          }
        },
        "tags": {
          "type": "array",
          "title": "Tags",
          "description": "The tags associated with the task definition",
          "items": {
            "type": "object"
          }
        },
        "registeredAt": {
          "type": "string",
          "title": "Registered At",
          "format": "date-time",
          "description": "The timestamp when the task definition was registered"
        }
      },
      "required": []
    },
    "mirrorProperties": {},
    "calculationProperties": {},
    "aggregationProperties": {},
    "relations": {
      "account": {
        "title": "Account",
        "target": "awsAccount",
        "required": false,
        "many": false
      }
    }
  }
]

ECS Task Definition mapping configuration (click to expand)

resources:
  - kind: AWS::ECS::TaskDefinition
    selector:
      query: 'true'
    port:
      entity:
        mappings:
          identifier: .Properties.TaskDefinitionArn
          title: .Properties.Family + ":" + (.Properties.Revision | tostring)
          blueprint: '"ecsTaskDefinition"'
          properties:
            taskDefinitionArn: .Properties.TaskDefinitionArn
            family: .Properties.Family
            revision: .Properties.Revision
            status: .Properties.Status
            containerDefinitions: .Properties.ContainerDefinitions
            cpu: .Properties.Cpu
            memory: .Properties.Memory
            networkMode: .Properties.NetworkMode
            requiresCompatibilities: .Properties.RequiresCompatibilities
            taskRoleArn: .Properties.TaskRoleArn
            executionRoleArn: .Properties.ExecutionRoleArn
            volumes: .Properties.Volumes
            placementConstraints: .Properties.PlacementConstraints
            tags: .Properties.Tags
            registeredAt: .Properties.RegisteredAt
          relations:
            account: .__ExtraContext.AccountId

For more details about ECS cluster properties, refer to the AWS ECS API documentation.