AWS v3
Port's AWS integration imports your AWS resources into Port, with flexible deployment options to match your needs. The integration periodically syncs your AWS resources so your Port catalog stays up-to-date with your AWS infrastructure.
Port's AWS integration is open source, view the source code here.
Deployment options
The integration can be deployed using one of the following methods:
- Hosted by Port: Fully managed by Port with zero maintenance required. Simply create IAM roles via CloudFormation, and Port handles the rest.
- Self-hosted: Deploy the integration in your own infrastructure using ECS, EC2, EKS, or as a one-off Docker run for complete control.
For detailed information about the IAM role architecture, see the IAM role architecture section of the installation page.
The integration supports AWS GovCloud.
When running a self-hosted GovCloud integration, it is recommended to run using the AssumeRole mode.
If you run in StaticCredentials mode, you will need to set the OCEAN__INTEGRATION__CONFIG__AWS_PARTITION environment variable to specify your AWS partition (for example, aws-us-gov for GovCloud).
Common use cases
Easily fill your software catalog with data directly from your AWS Organization, for example:
- Map all the resources in your AWS Accounts, including ECS Clusters, S3 Buckets, and EC2 Instances with zero maintenance required.
- Keep your Port catalog synchronized with your AWS infrastructure through periodic updates.
- Use relations to create complete, easily digestible views of your AWS infrastructure inside Port.
- Enjoy a fully managed experience with no infrastructure to maintain or updates to apply.
The integration supports syncing resources across multiple AWS accounts using automatic account discovery via AWS Organizations. See the account discovery section of the installation page for details.
Key advantages
AWS Hosted by Port provides several advantages over the AWS on-premise integration:
- Fully hosted: No infrastructure to maintain, update, or monitor.
- Simplified installation: Just deploy CloudFormation templates to create IAM roles.
- Complete data: Ensures no missing or incomplete resource information.
Configuration
Port integrations use a YAML mapping block to ingest data from the third-party api into Port.
The mapping makes use of the JQ JSON processor to select, modify, concatenate, transform and perform other operations on existing fields and values from the integration API.
The AWS Hosted by Port integration returns all resource properties in PascalCase (for example: Arn, BucketName, CreationDate). When writing mappings and JQ expressions, reference properties using PascalCasing as shown in the examples below.
Default mapping configuration
This is the default mapping configuration you get after installing AWS Hosted by Port.
Default mapping configuration (click to expand)
deleteDependentEntities: true
createMissingRelatedEntities: true
enableMergeEntity: true
resources:
- kind: AWS::Account::Info
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.Id
title: .Properties.Name
blueprint: '"awsAccount"'
- kind: AWS::S3::Bucket
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.Arn
title: .Properties.BucketName
blueprint: '"s3Bucket"'
properties:
arn: .Properties.Arn
region: .Properties.LocationConstraint
creationDate: .Properties.CreationDate
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
- kind: AWS::EC2::Instance
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.InstanceId
title: .Properties.InstanceId
blueprint: '"ec2Instance"'
properties:
instanceType: .Properties.InstanceType
state: .Properties.State.Name
publicIpAddress: .Properties.PublicIpAddress
privateIpAddress: .Properties.PrivateIpAddress
tags: .Properties.Tags
arn: >-
"arn:aws:ec2:" + .__Region + ":" + .__AccountId + ":instance/" +
.Properties.InstanceId
relations:
account: .__ExtraContext.AccountId
- kind: AWS::ECS::Cluster
selector:
query: 'true'
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
Monitoring and sync status
To learn more about how to monitor and check the sync status of your integration, see the relevant documentation.
Mapping & selectors per resource
The following sections show examples of blueprint definitions and mapping configurations for common AWS resources.
{
"identifier": "sqsQueue",
"title": "SQS Queue",
"icon": "AWS",
"schema": {
"properties": {
"arn": {
"type": "string",
"title": "ARN"
},
"region": {
"type": "string",
"title": "Region"
},
"queueUrl": {
"type": "string",
"title": "Queue URL"
},
"approximateNumberOfMessages": {
"type": "number",
"title": "Approx Number of Messages"
},
"visibilityTimeout": {
"type": "number",
"title": "Visibility Timeout (seconds)"
},
"messageRetentionPeriod": {
"type": "number",
"title": "Message Retention Period"
},
"sqsManagedSseEnabled": {
"type": "boolean",
"title": "SQS Managed SSE Enabled"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
- kind: AWS::SQS::Queue
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.QueueArn
title: .Properties.QueueUrl | split("/") | .[-1]
blueprint: '"sqsQueue"'
properties:
arn: .Properties.QueueArn
region: .__ExtraContext.Region
queueUrl: .Properties.QueueUrl
approximateNumberOfMessages: .Properties.ApproximateNumberOfMessages
visibilityTimeout: .Properties.VisibilityTimeout
messageRetentionPeriod: .Properties.MessageRetentionPeriod
sqsManagedSseEnabled: .Properties.SqsManagedSseEnabled
relations:
account: .__ExtraContext.AccountId
{
"identifier": "s3Bucket",
"title": "S3 Bucket",
"icon": "AWS",
"schema": {
"properties": {
"arn": {
"type": "string",
"title": "ARN"
},
"creationDate": {
"type": "string",
"format": "date-time",
"title": "Creation Date"
},
"tags": {
"type": "array",
"title": "Tags"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": true,
"many": false
}
}
}
- kind: AWS::S3::Bucket
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.Arn
title: .Properties.BucketName
blueprint: '"s3Bucket"'
properties:
arn: .Properties.Arn
creationDate: .Properties.CreationDate
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
{
"identifier": "ec2Instance",
"title": "EC2 Instance",
"icon": "AWS",
"schema": {
"properties": {
"instanceArn": {
"type": "string",
"title": "Instance ARN"
},
"instanceId": {
"type": "string",
"title": "Instance ID"
},
"instanceType": {
"type": "string",
"title": "Instance Type"
},
"availabilityZone": {
"type": "string",
"title": "Availability Zone"
},
"tags": {
"type": "array",
"title": "Tags"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": true,
"many": false
}
}
}
- kind: AWS::EC2::Instance
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.InstanceId
title: .Properties.InstanceId
blueprint: '"ec2Instance"'
properties:
instanceArn: .Properties.InstanceArn
instanceId: .Properties.InstanceId
instanceType: .Properties.InstanceType
availabilityZone: .Properties.AvailabilityZone
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
{
"identifier": "ebsVolume",
"title": "EBS Volume",
"icon": "AWS",
"schema": {
"properties": {
"volumeType": {
"type": "string",
"title": "Volume Type",
"description": "The volume type (gp2, gp3, io1, io2, st1, sc1, standard)"
},
"size": {
"type": "number",
"title": "Size (GiB)",
"description": "The size of the volume in GiB"
},
"iops": {
"type": "number",
"title": "IOPS",
"description": "The number of I/O operations per second"
},
"throughput": {
"type": "number",
"title": "Throughput (MiB/s)",
"description": "The throughput provisioned for the volume in MiB/s"
},
"availabilityZone": {
"type": "string",
"title": "Availability Zone",
"description": "The Availability Zone in which the volume resides"
},
"state": {
"type": "string",
"title": "State",
"description": "The current state of the volume",
"enum": [
"creating",
"available",
"in-use",
"deleting",
"deleted",
"error"
]
},
"creationDate": {
"type": "string",
"title": "Creation Date",
"description": "The date and time the volume was created",
"format": "date-time"
},
"encrypted": {
"type": "boolean",
"title": "Encrypted",
"description": "Indicates whether the volume is encrypted"
},
"autoEnableIO": {
"type": "boolean",
"title": "Auto Enable IO",
"description": "Indicates whether the volume is auto-enabled for I/O operations"
},
"tags": {
"type": "array",
"title": "Tags",
"description": "Tags associated with the volume",
"items": {
"type": "object"
}
},
"arn": {
"type": "string",
"title": "ARN",
"description": "The Amazon Resource Name (ARN) of the volume"
}
},
"required": []
},
"calculationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::EC2::Volume
selector:
query: 'true'
includeActions:
- DescribeVolumeAttributeAction
port:
entity:
mappings:
identifier: .Properties.VolumeId
title: '(.Properties.Tags // [] | map(select(.Key == "Name")) | first | .Value) // .Properties.VolumeId'
blueprint: '"ebsVolume"'
properties:
volumeType: .Properties.VolumeType
size: .Properties.Size
iops: .Properties.Iops
throughput: .Properties.Throughput
availabilityZone: .Properties.AvailabilityZone
state: .Properties.State
creationDate: .Properties.CreateTime
encrypted: .Properties.Encrypted
autoEnableIO: .Properties.AutoEnableIO
tags: .Properties.Tags
arn: '"arn:aws:ec2:" + .__ExtraContext.Region + ":" + .__ExtraContext.AccountId + ":volume/" + .Properties.VolumeId'
relations:
account: .__ExtraContext.AccountId
{
"identifier": "ecrRepository",
"title": "ECR Repository",
"icon": "AWS",
"schema": {
"properties": {
"repositoryUri": {
"type": "string",
"title": "Repository URI"
},
"registryId": {
"type": "string",
"title": "Registry ID"
},
"createdAt": {
"type": "string",
"title": "Created At"
},
"imageTagMutability": {
"type": "string",
"title": "Image Tag Mutability"
},
"imageScanningConfiguration": {
"type": "object",
"title": "Image Scanning Configuration"
},
"encryptionConfiguration": {
"type": "object",
"title": "Encryption Configuration"
},
"tags": {
"type": "array",
"title": "Tags"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": true,
"many": false
}
}
}
- kind: AWS::ECR::Repository
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.RepositoryArn
title: .Properties.RepositoryName
blueprint: '"ecrRepository"'
properties:
repositoryUri: .Properties.RepositoryUri
registryId: .Properties.RegistryId
createdAt: .Properties.CreatedAt
imageTagMutability: .Properties.ImageTagMutability
imageScanningConfiguration: .Properties.ImageScanningConfiguration
encryptionConfiguration: .Properties.EncryptionConfiguration
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
{
"identifier": "ecsCluster",
"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"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": true,
"many": false
}
}
}
- kind: AWS::ECS::Cluster
selector:
query: 'true'
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
{
"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"
},
"pendingCount": {
"type": "number",
"title": "Pending Count",
"description": "The number of tasks in the PENDING state"
},
"launchType": {
"type": "string",
"title": "Launch Type",
"description": "The launch type of the service",
"enum": [
"EC2",
"FARGATE",
"EXTERNAL"
]
},
"schedulingStrategy": {
"type": "string",
"title": "Scheduling Strategy",
"description": "The scheduling strategy to use for the service",
"enum": [
"REPLICA",
"DAEMON"
]
},
"status": {
"type": "string",
"title": "Status",
"description": "The current status of the service",
"enum": [
"ACTIVE",
"DRAINING",
"INACTIVE"
]
},
"deploymentConfiguration": {
"type": "object",
"title": "Deployment Configuration",
"description": "The deployment configuration for the service"
},
"deploymentController": {
"type": "object",
"title": "Deployment Controller",
"description": "The deployment controller type for the service"
},
"deployments": {
"type": "array",
"title": "Deployments",
"description": "The current deployments of the service",
"items": {
"type": "object"
}
},
"enableECSManagedTags": {
"type": "boolean",
"title": "ECS Managed Tags",
"description": "Whether to enable ECS managed tags"
},
"enableExecuteCommand": {
"type": "boolean",
"title": "Execute Command",
"description": "Whether to enable ECS Exec for the service"
},
"events": {
"type": "array",
"title": "Events",
"description": "The events associated with the service",
"items": {
"type": "object"
}
},
"healthCheckGracePeriodSeconds": {
"type": "number",
"title": "Health Check Grace Period",
"description": "The grace period for health checks in seconds"
},
"loadBalancers": {
"type": "array",
"title": "Load Balancers",
"description": "The load balancers associated with the service",
"items": {
"type": "object"
}
},
"networkConfiguration": {
"type": "object",
"title": "Network Configuration",
"description": "The network configuration for the service"
},
"placementConstraints": {
"type": "array",
"title": "Placement Constraints",
"description": "The placement constraints for the service",
"items": {
"type": "object"
}
},
"placementStrategy": {
"type": "array",
"title": "Placement Strategy",
"description": "The placement strategy for the service",
"items": {
"type": "object"
}
},
"platformFamily": {
"type": "string",
"title": "Platform Family",
"description": "The platform family for the service"
},
"platformVersion": {
"type": "string",
"title": "Platform Version",
"description": "The platform version for the service"
},
"propagateTags": {
"type": "string",
"title": "Propagate Tags",
"description": "Whether to propagate tags from the service or task definition",
"enum": [
"SERVICE",
"TASK_DEFINITION"
]
},
"roleArn": {
"type": "string",
"title": "Role ARN",
"description": "The ARN of the IAM role associated with the service"
},
"serviceRegistries": {
"type": "array",
"title": "Service Registries",
"description": "The service registries associated with the service",
"items": {
"type": "object"
}
},
"tags": {
"type": "array",
"title": "Tags",
"description": "The tags associated with the service",
"items": {
"type": "object"
}
},
"taskSets": {
"type": "array",
"title": "Task Sets",
"description": "The task sets associated with the service",
"items": {
"type": "object"
}
},
"capacityProviderStrategy": {
"type": "array",
"title": "Capacity Provider Strategy",
"description": "The capacity provider strategy for the service",
"items": {
"type": "object"
}
},
"availabilityZoneRebalancing": {
"type": "string",
"title": "Availability Zone Rebalancing",
"description": "Whether availability zone rebalancing is enabled",
"enum": [
"ENABLED",
"DISABLED"
]
},
"createdAt": {
"type": "string",
"title": "Created At",
"description": "The timestamp when the service was created",
"format": "date-time"
},
"createdBy": {
"type": "string",
"title": "Created By",
"description": "The ARN of the entity that created the service"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
},
"cluster": {
"title": "Cluster",
"target": "ecsCluster",
"required": false,
"many": false
}
}
}
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
pendingCount: .Properties.PendingCount
launchType: .Properties.LaunchType
schedulingStrategy: .Properties.SchedulingStrategy
status: .Properties.Status
deploymentConfiguration: .Properties.DeploymentConfiguration
deploymentController: .Properties.DeploymentController
deployments: .Properties.Deployments
enableECSManagedTags: .Properties.EnableECSManagedTags
enableExecuteCommand: .Properties.EnableExecuteCommand
events: .Properties.Events
healthCheckGracePeriodSeconds: .Properties.HealthCheckGracePeriodSeconds
loadBalancers: .Properties.LoadBalancers
networkConfiguration: .Properties.NetworkConfiguration
placementConstraints: .Properties.PlacementConstraints
placementStrategy: .Properties.PlacementStrategy
platformFamily: .Properties.PlatformFamily
platformVersion: .Properties.PlatformVersion
propagateTags: .Properties.PropagateTags
roleArn: .Properties.RoleArn
serviceRegistries: .Properties.ServiceRegistries
tags: .Properties.Tags
taskSets: .Properties.TaskSets
capacityProviderStrategy: .Properties.CapacityProviderStrategy
availabilityZoneRebalancing: .Properties.AvailabilityZoneRebalancing
createdAt: .Properties.CreatedAt
createdBy: .Properties.CreatedBy
relations:
account: .__ExtraContext.AccountId
cluster: .Properties.ClusterArn
{
"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
}
}
}
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
{
"identifier": "eksCluster",
"title": "EKS Cluster",
"icon": "AWS",
"schema": {
"properties": {
"arn": {
"type": "string",
"title": "ARN"
},
"name": {
"type": "string",
"title": "Name"
},
"version": {
"type": "string",
"title": "Kubernetes Version"
},
"status": {
"type": "string",
"title": "Status"
},
"endpoint": {
"type": "string",
"title": "Endpoint"
},
"roleArn": {
"type": "string",
"title": "Role ARN"
},
"tags": {
"type": "object",
"title": "Tags"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
- kind: AWS::EKS::Cluster
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.Arn
title: .Properties.Name
blueprint: '"eksCluster"'
properties:
arn: .Properties.Arn
name: .Properties.Name
version: .Properties.Version
status: .Properties.Status
endpoint: .Properties.Endpoint
roleArn: .Properties.RoleArn
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
{
"identifier": "awsOrganizationAccount",
"title": "Organizations Account",
"icon": "AWS",
"schema": {
"properties": {
"arn": {
"type": "string",
"title": "ARN"
},
"email": {
"type": "string",
"title": "Email"
},
"status": {
"type": "string",
"title": "Status"
},
"joinedTimestamp": {
"type": "string",
"title": "Joined Timestamp"
},
"joinedMethod": {
"type": "string",
"title": "Joined Method"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {}
}
- kind: AWS::Organizations::Account
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.Id
title: .Properties.AccountName
blueprint: '"awsOrganizationAccount"'
properties:
arn: .Properties.Arn
email: .Properties.Email
status: .Properties.Status
joinedTimestamp: .Properties.JoinedTimestamp
joinedMethod: .Properties.JoinedMethod
{
"identifier": "rdsDbInstance",
"title": "RDS DB Instance",
"icon": "AWS",
"schema": {
"properties": {
"dbInstanceIdentifier": {
"type": "string",
"title": "DB Instance Identifier"
},
"dbInstanceArn": {
"type": "string",
"title": "ARN"
},
"engine": {
"type": "string",
"title": "Engine"
},
"dbInstanceClass": {
"type": "string",
"title": "Instance Class"
},
"dbInstanceStatus": {
"type": "string",
"title": "Status"
},
"multiAZ": {
"type": "boolean",
"title": "Multi-AZ"
},
"storageEncrypted": {
"type": "boolean",
"title": "Storage Encrypted"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
- kind: AWS::RDS::DBInstance
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.DBInstanceArn
title: .Properties.DBInstanceIdentifier
blueprint: '"rdsDbInstance"'
properties:
dbInstanceIdentifier: .Properties.DBInstanceIdentifier
dbInstanceArn: .Properties.DBInstanceArn
engine: .Properties.Engine
dbInstanceClass: .Properties.DBInstanceClass
dbInstanceStatus: .Properties.DBInstanceStatus
multiAZ: .Properties.MultiAZ
storageEncrypted: .Properties.StorageEncrypted
relations:
account: .__ExtraContext.AccountId
{
"identifier": "rdsDbCluster",
"title": "RDS DB Cluster",
"icon": "AWS",
"schema": {
"properties": {
"activityStreamStatus": {
"type": "string",
"title": "Activity Stream Status",
"description": "The status of the database activity stream"
},
"associatedRoles": {
"type": "array",
"title": "Associated Roles",
"description": "The IAM roles associated with the DB cluster",
"items": {
"type": "object"
}
},
"autoMinorVersionUpgrade": {
"type": "boolean",
"title": "Auto Minor Version Upgrade",
"description": "Whether minor version upgrades are applied automatically"
},
"availabilityZones": {
"type": "array",
"title": "Availability Zones",
"description": "The Availability Zones where the DB cluster is deployed",
"items": {
"type": "string"
}
},
"backupRetentionPeriod": {
"type": "number",
"title": "Backup Retention Period",
"description": "The number of days to retain automated backups"
},
"clusterCreateTime": {
"type": "string",
"title": "Cluster Create Time",
"description": "The time when the DB cluster was created"
},
"copyTagsToSnapshot": {
"type": "boolean",
"title": "Copy Tags To Snapshot",
"description": "Whether to copy tags to snapshots"
},
"crossAccountClone": {
"type": "boolean",
"title": "Cross Account Clone",
"description": "Whether cross-account cloning is enabled"
},
"databaseName": {
"type": "string",
"title": "Database Name",
"description": "The name of the initial database"
},
"dbClusterArn": {
"type": "string",
"title": "ARN",
"description": "The Amazon Resource Name (ARN) of the DB cluster"
},
"dbClusterIdentifier": {
"type": "string",
"title": "DB Cluster Identifier",
"description": "The unique identifier of the RDS DB cluster"
},
"dbClusterMembers": {
"type": "array",
"title": "DB Cluster Members",
"description": "The DB instances that belong to the cluster",
"items": {
"type": "object"
}
},
"dbClusterResourceId": {
"type": "string",
"title": "DB Cluster Resource ID",
"description": "The unique resource identifier for the DB cluster"
},
"deletionProtection": {
"type": "boolean",
"title": "Deletion Protection",
"description": "Whether deletion protection is enabled"
},
"earliestRestorableTime": {
"type": "string",
"title": "Earliest Restorable Time",
"description": "The earliest time to which the DB cluster can be restored"
},
"endpoint": {
"type": "string",
"title": "Writer Endpoint",
"description": "The writer endpoint for the DB cluster"
},
"engine": {
"type": "string",
"title": "Engine",
"description": "The database engine type (e.g., aurora-mysql, aurora-postgresql)"
},
"engineMode": {
"type": "string",
"title": "Engine Mode",
"description": "The engine mode of the DB cluster (e.g., provisioned, serverless)"
},
"engineVersion": {
"type": "string",
"title": "Engine Version",
"description": "The version of the database engine"
},
"globalWriteForwardingStatus": {
"type": "string",
"title": "Global Write Forwarding Status",
"description": "The status of write forwarding for a secondary cluster in a global database"
},
"httpEndpointEnabled": {
"type": "boolean",
"title": "HTTP Endpoint Enabled",
"description": "Whether the HTTP endpoint (Data API) is enabled for Aurora Serverless"
},
"iamDatabaseAuthenticationEnabled": {
"type": "boolean",
"title": "IAM Database Authentication Enabled",
"description": "Whether IAM database authentication is enabled"
},
"kmsKeyId": {
"type": "string",
"title": "KMS Key ID",
"description": "The KMS key identifier for encryption"
},
"latestRestorableTime": {
"type": "string",
"title": "Latest Restorable Time",
"description": "The latest time to which the DB cluster can be restored"
},
"masterUsername": {
"type": "string",
"title": "Master Username",
"description": "The master username for the DB cluster"
},
"multiAZ": {
"type": "boolean",
"title": "Multi-AZ",
"description": "Whether the DB cluster is deployed across multiple Availability Zones"
},
"networkType": {
"type": "string",
"title": "Network Type",
"description": "The network type for the DB cluster"
},
"port": {
"type": "number",
"title": "Port",
"description": "The port number for the DB cluster"
},
"preferredBackupWindow": {
"type": "string",
"title": "Preferred Backup Window",
"description": "The preferred backup window"
},
"preferredMaintenanceWindow": {
"type": "string",
"title": "Preferred Maintenance Window",
"description": "The preferred maintenance window"
},
"readerEndpoint": {
"type": "string",
"title": "Reader Endpoint",
"description": "The reader endpoint for load-balancing read connections across cluster members"
},
"status": {
"type": "string",
"title": "Status",
"description": "The current status of the DB cluster",
"enum": [
"available",
"backing-up",
"creating",
"deleting",
"failing-over",
"inaccessible-encryption-credentials",
"maintenance",
"migrating",
"modifying",
"promoting",
"renaming",
"resetting-master-credentials",
"scaling",
"starting",
"stopped",
"stopping",
"upgrading"
]
},
"storageEncrypted": {
"type": "boolean",
"title": "Storage Encrypted",
"description": "Whether the DB cluster storage is encrypted"
},
"storageType": {
"type": "string",
"title": "Storage Type",
"description": "The storage type of the DB cluster"
},
"tags": {
"type": "array",
"title": "Tags",
"description": "The tags associated with the DB cluster",
"items": {
"type": "object",
"properties": {
"Key": {
"type": "string"
},
"Value": {
"type": "string"
}
}
}
},
"vpcSecurityGroups": {
"type": "array",
"title": "VPC Security Groups",
"description": "The VPC security groups associated with the DB cluster",
"items": {
"type": "object"
}
},
"dbSubnetGroup": {
"type": "string",
"title": "DB Subnet Group",
"description": "The subnet group associated with the DB cluster"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::RDS::DBCluster
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.DBClusterArn
title: .Properties.DBClusterIdentifier
blueprint: '"rdsDbCluster"'
properties:
activityStreamStatus: .Properties.ActivityStreamStatus
associatedRoles: .Properties.AssociatedRoles
autoMinorVersionUpgrade: .Properties.AutoMinorVersionUpgrade
availabilityZones: .Properties.AvailabilityZones
backupRetentionPeriod: .Properties.BackupRetentionPeriod
clusterCreateTime: .Properties.ClusterCreateTime
copyTagsToSnapshot: .Properties.CopyTagsToSnapshot
crossAccountClone: .Properties.CrossAccountClone
databaseName: .Properties.DatabaseName
dbClusterArn: .Properties.DBClusterArn
dbClusterIdentifier: .Properties.DBClusterIdentifier
dbClusterMembers: .Properties.DBClusterMembers
dbClusterResourceId: .Properties.DbClusterResourceId
deletionProtection: .Properties.DeletionProtection
earliestRestorableTime: .Properties.EarliestRestorableTime
endpoint: .Properties.Endpoint
engine: .Properties.Engine
engineMode: .Properties.EngineMode
engineVersion: .Properties.EngineVersion
globalWriteForwardingStatus: .Properties.GlobalWriteForwardingStatus
httpEndpointEnabled: .Properties.HttpEndpointEnabled
iamDatabaseAuthenticationEnabled: .Properties.IAMDatabaseAuthenticationEnabled
kmsKeyId: .Properties.KmsKeyId
latestRestorableTime: .Properties.LatestRestorableTime
masterUsername: .Properties.MasterUsername
multiAZ: .Properties.MultiAZ
networkType: .Properties.NetworkType
port: .Properties.Port
preferredBackupWindow: .Properties.PreferredBackupWindow
preferredMaintenanceWindow: .Properties.PreferredMaintenanceWindow
readerEndpoint: .Properties.ReaderEndpoint
status: .Properties.Status
storageEncrypted: .Properties.StorageEncrypted
storageType: .Properties.StorageType
tags: .Properties.Tags
vpcSecurityGroups: .Properties.VpcSecurityGroups
dbSubnetGroup: .Properties.DBSubnetGroup
relations:
account: .__ExtraContext.AccountId
{
"identifier": "lambdaFunction",
"title": "Lambda Function",
"icon": "AWS",
"schema": {
"properties": {
"functionName": {
"type": "string",
"title": "Function Name"
},
"functionArn": {
"type": "string",
"title": "Function ARN"
},
"runtime": {
"type": "string",
"title": "Runtime"
},
"handler": {
"type": "string",
"title": "Handler"
},
"memorySize": {
"type": "number",
"title": "Memory Size"
},
"timeout": {
"type": "number",
"title": "Timeout"
},
"state": {
"type": "string",
"title": "State"
},
"lastModified": {
"type": "string",
"title": "Last Modified"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
- kind: AWS::Lambda::Function
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.FunctionArn
title: .Properties.FunctionName
blueprint: '"lambdaFunction"'
properties:
functionName: .Properties.FunctionName
functionArn: .Properties.FunctionArn
runtime: .Properties.Runtime
handler: .Properties.Handler
memorySize: .Properties.MemorySize
timeout: .Properties.Timeout
state: .Properties.State
lastModified: .Properties.LastModified
relations:
account: .__ExtraContext.AccountId
{
"identifier": "awsAccount",
"title": "AWS Account",
"icon": "AWS",
"schema": {
"properties": {},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {}
}
- kind: AWS::Account::Info
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.Id
title: .Properties.Name
blueprint: '"awsAccount"'
{
"identifier": "mskCluster",
"title": "MSK Cluster",
"icon": "AWS",
"schema": {
"properties": {
"clusterArn": {
"type": "string",
"title": "ARN"
},
"state": {
"type": "string",
"title": "State"
},
"kafkaVersion": {
"type": "string",
"title": "Kafka Version"
},
"numberOfBrokerNodes": {
"type": "number",
"title": "Number of Broker Nodes"
},
"instanceType": {
"type": "string",
"title": "Instance Type"
},
"enhancedMonitoring": {
"type": "string",
"title": "Enhanced Monitoring"
},
"clientAuthentication": {
"type": "object",
"title": "Client Authentication"
},
"encryptionInTransit": {
"type": "string",
"title": "Encryption In Transit"
},
"creationTime": {
"type": "string",
"title": "Creation Time",
"format": "date-time"
},
"tags": {
"type": "object",
"title": "Tags"
}
},
"required": []
},
"calculationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
- kind: AWS::MSK::Cluster
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.ClusterArn
title: .Properties.ClusterName
blueprint: '"mskCluster"'
properties:
clusterArn: .Properties.ClusterArn
state: .Properties.State
kafkaVersion: .Properties.CurrentBrokerSoftwareInfo.KafkaVersion
numberOfBrokerNodes: .Properties.NumberOfBrokerNodes
instanceType: .Properties.BrokerNodeGroupInfo.InstanceType
enhancedMonitoring: .Properties.EnhancedMonitoring
clientAuthentication: .Properties.ClientAuthentication
encryptionInTransit: .Properties.EncryptionInfo.EncryptionInTransit.ClientBroker
creationTime: .Properties.CreationTime
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
{
"identifier": "mskServerlessCluster",
"title": "MSK Serverless Cluster",
"icon": "AWS",
"schema": {
"properties": {
"arn": {
"type": "string",
"title": "ARN",
"description": "The Amazon Resource Name (ARN) of the MSK serverless cluster"
},
"clusterName": {
"type": "string",
"title": "Cluster Name",
"description": "The name of the MSK serverless cluster"
},
"state": {
"type": "string",
"title": "State",
"description": "The current state of the cluster",
"enum": [
"ACTIVE",
"CREATING",
"DELETING",
"FAILED",
"HEALING",
"MAINTENANCE",
"REBOOTING_BROKER",
"UPDATING"
]
},
"creationTime": {
"type": "string",
"title": "Creation Time",
"description": "The date and time when the cluster was created",
"format": "date-time"
},
"currentVersion": {
"type": "string",
"title": "Current Version",
"description": "The current version of the MSK cluster"
},
"vpcConfigs": {
"type": "array",
"title": "VPC Configs",
"description": "The VPC configuration for the serverless cluster",
"items": {
"type": "object"
}
},
"clientAuthentication": {
"type": "object",
"title": "Client Authentication",
"description": "The client authentication configuration for the cluster"
},
"tags": {
"type": "object",
"title": "Tags",
"description": "Tags associated with the cluster"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::MSK::ServerlessCluster
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.ClusterArn
title: .Properties.ClusterName
blueprint: '"mskServerlessCluster"'
properties:
arn: .Properties.ClusterArn
clusterName: .Properties.ClusterName
state: .Properties.State
creationTime: .Properties.CreationTime
currentVersion: .Properties.CurrentVersion
vpcConfigs: .Properties.Serverless.VpcConfigs
clientAuthentication: .Properties.Serverless.ClientAuthentication
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
{
"identifier": "elasticacheCluster",
"title": "ElastiCache Cluster",
"icon": "AWS",
"schema": {
"properties": {
"arn": {
"type": "string",
"title": "ARN"
},
"cacheClusterId": {
"type": "string",
"title": "Cluster ID"
},
"cacheClusterStatus": {
"type": "string",
"title": "Status"
},
"cacheNodeType": {
"type": "string",
"title": "Node Type"
},
"engine": {
"type": "string",
"title": "Engine"
},
"engineVersion": {
"type": "string",
"title": "Engine Version"
},
"numCacheNodes": {
"type": "number",
"title": "Number of Nodes"
},
"preferredAvailabilityZone": {
"type": "string",
"title": "Availability Zone"
},
"cacheClusterCreateTime": {
"type": "string",
"title": "Created At",
"format": "date-time"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
- kind: AWS::ElastiCache::CacheCluster
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.ARN
title: .Properties.CacheClusterId
blueprint: '"elasticacheCluster"'
properties:
arn: .Properties.ARN
cacheClusterId: .Properties.CacheClusterId
cacheClusterStatus: .Properties.CacheClusterStatus
cacheNodeType: .Properties.CacheNodeType
engine: .Properties.Engine
engineVersion: .Properties.EngineVersion
numCacheNodes: .Properties.NumCacheNodes
preferredAvailabilityZone: .Properties.PreferredAvailabilityZone
cacheClusterCreateTime: .Properties.CacheClusterCreateTime
relations:
account: .__ExtraContext.AccountId
{
"identifier": "memoryDbUser",
"title": "MemoryDB User",
"icon": "AWS",
"schema": {
"properties": {
"arn": {
"type": "string",
"title": "ARN",
"description": "The Amazon Resource Name (ARN) of the MemoryDB user"
},
"status": {
"type": "string",
"title": "Status",
"description": "The current status of the user (active, modifying, or deleting)"
},
"accessString": {
"type": "string",
"title": "Access String",
"description": "Access permissions string used for this user account"
},
"aclNames": {
"type": "array",
"title": "ACL Names",
"description": "The names of the Access Control Lists (ACLs) the user belongs to",
"items": {
"type": "string"
}
},
"minimumEngineVersion": {
"type": "string",
"title": "Minimum Engine Version",
"description": "The minimum engine version supported for the user"
},
"authentication": {
"type": "object",
"title": "Authentication",
"description": "The authentication mode for the user"
},
"tags": {
"type": "array",
"title": "Tags",
"description": "Tags associated with the MemoryDB user",
"items": {
"type": "object"
}
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::MemoryDB::User
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.ARN
title: .Properties.Name
blueprint: '"memoryDbUser"'
properties:
arn: .Properties.ARN
status: .Properties.Status
accessString: .Properties.AccessString
aclNames: .Properties.ACLNames
minimumEngineVersion: .Properties.MinimumEngineVersion
authentication: .Properties.Authentication
tags: .Properties.TagList
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codeBuildProject",
"title": "CodeBuild Project",
"icon": "AWS",
"schema": {
"properties": {
"name": {
"type": "string",
"title": "Project Name",
"description": "The name of the CodeBuild project"
},
"arn": {
"type": "string",
"title": "ARN",
"description": "The Amazon Resource Name (ARN) of the CodeBuild project"
},
"description": {
"type": "string",
"title": "Description",
"description": "A description of the CodeBuild project"
},
"serviceRole": {
"type": "string",
"title": "Service Role",
"description": "The ARN of the AWS Identity and Access Management (IAM) service role"
},
"timeoutInMinutes": {
"type": "number",
"title": "Timeout (Minutes)",
"description": "How long, in minutes, from 5 to 480, for AWS CodeBuild to wait before timing out any related build"
},
"queuedTimeoutInMinutes": {
"type": "number",
"title": "Queued Timeout (Minutes)",
"description": "The number of minutes a build is allowed to be queued before timing out"
},
"encryptionKey": {
"type": "string",
"title": "Encryption Key",
"description": "The AWS Key Management Service (AWS KMS) customer master key (CMK) to be used for encrypting the build project artifacts"
},
"environment": {
"type": "object",
"title": "Build Environment",
"description": "Information about the build environment for the build project"
},
"source": {
"type": "object",
"title": "Source",
"description": "Information about the build input source code for the build project"
},
"artifacts": {
"type": "object",
"title": "Artifacts",
"description": "Information about the build output artifacts for the build project"
},
"created": {
"type": "string",
"title": "Created",
"description": "When the build project was created",
"format": "date-time"
},
"lastModified": {
"type": "string",
"title": "Last Modified",
"description": "When the build project was last modified",
"format": "date-time"
},
"projectVisibility": {
"type": "string",
"title": "Project Visibility",
"description": "The visibility setting for the project",
"enum": [
"PRIVATE",
"PUBLIC_READ"
]
},
"concurrentBuildLimit": {
"type": "number",
"title": "Concurrent Build Limit",
"description": "The maximum number of concurrent builds that are allowed for this project"
},
"tags": {
"type": "array",
"title": "Tags",
"description": "Tags associated with the CodeBuild project",
"items": {
"type": "object"
}
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodeBuild::Project
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.Arn
title: .Properties.Name
blueprint: '"codeBuildProject"'
properties:
name: .Properties.Name
arn: .Properties.Arn
description: .Properties.Description
serviceRole: .Properties.ServiceRole
timeoutInMinutes: .Properties.TimeoutInMinutes
queuedTimeoutInMinutes: .Properties.QueuedTimeoutInMinutes
encryptionKey: .Properties.EncryptionKey
environment: .Properties.Environment
source: .Properties.Source
artifacts: .Properties.Artifacts
created: .Properties.Created
lastModified: .Properties.LastModified
projectVisibility: .Properties.ProjectVisibility
concurrentBuildLimit: .Properties.ConcurrentBuildLimit
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codeBuildBuildRun",
"title": "CodeBuild Build Run",
"icon": "AWS",
"schema": {
"properties": {
"arn": {
"type": "string",
"title": "ARN",
"description": "The Amazon Resource Name (ARN) of the build run"
},
"projectName": {
"type": "string",
"title": "Project Name",
"description": "The name of the CodeBuild project"
},
"buildNumber": {
"type": "number",
"title": "Build Number",
"description": "The build number"
},
"buildStatus": {
"type": "string",
"title": "Build Status",
"description": "The current status of the build",
"enum": [
"SUCCEEDED",
"FAILED",
"FAULT",
"TIMED_OUT",
"IN_PROGRESS",
"STOPPED"
]
},
"currentPhase": {
"type": "string",
"title": "Current Phase",
"description": "The current phase of the build"
},
"startTime": {
"type": "string",
"title": "Start Time",
"description": "The time the build started",
"format": "date-time"
},
"endTime": {
"type": "string",
"title": "End Time",
"description": "The time the build ended",
"format": "date-time"
},
"sourceVersion": {
"type": "string",
"title": "Source Version",
"description": "The version of the source code"
},
"buildComplete": {
"type": "boolean",
"title": "Build Complete",
"description": "Whether the build is complete"
},
"initiator": {
"type": "string",
"title": "Initiator",
"description": "The entity that initiated the build"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodeBuild::BuildRun
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.Id
title: .Properties.ProjectName + " - Build " + (.Properties.BuildNumber | tostring)
blueprint: '"codeBuildBuildRun"'
properties:
arn: .Properties.Arn
projectName: .Properties.ProjectName
buildNumber: .Properties.BuildNumber
buildStatus: .Properties.BuildStatus
currentPhase: .Properties.CurrentPhase
startTime: .Properties.StartTime
endTime: .Properties.EndTime
sourceVersion: .Properties.SourceVersion
buildComplete: .Properties.BuildComplete
initiator: .Properties.Initiator
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codeDeployApplication",
"title": "CodeDeploy Application",
"icon": "AWS",
"schema": {
"properties": {
"applicationName": {
"type": "string",
"title": "Application Name"
},
"applicationId": {
"type": "string",
"title": "Application ID"
},
"createTime": {
"type": "string",
"title": "Create Time",
"format": "date-time"
},
"linkedToGitHub": {
"type": "boolean",
"title": "Linked To GitHub"
},
"gitHubAccountName": {
"type": "string",
"title": "GitHub Account Name"
},
"computePlatform": {
"type": "string",
"title": "Compute Platform"
},
"tags": {
"type": "array",
"title": "Tags",
"description": "Tags associated with the Application",
"items": {
"type": "object"
}
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodeDeploy::Application
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.ApplicationId
title: .Properties.ApplicationName
blueprint: '"codeDeployApplication"'
properties:
applicationName: .Properties.ApplicationName
applicationId: .Properties.ApplicationId
createTime: .Properties.CreateTime
linkedToGitHub: .Properties.LinkedToGitHub
gitHubAccountName: .Properties.GitHubAccountName
computePlatform: .Properties.ComputePlatform
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codedeployDeploymentGroup",
"title": "CodeDeploy Deployment Group",
"icon": "AWS",
"schema": {
"properties": {
"applicationName": {
"type": "string",
"title": "Application Name",
"description": "The CodeDeploy application name"
},
"deploymentGroupId": {
"type": "string",
"title": "Deployment Group ID",
"description": "The deployment group ID"
},
"serviceRoleArn": {
"type": "string",
"title": "Service Role ARN",
"description": "The ARN of the service role for the deployment group"
},
"computePlatform": {
"type": "string",
"title": "Compute Platform",
"description": "The compute platform for the deployment group",
"enum": [
"Server",
"Lambda",
"ECS"
]
},
"deploymentStyle": {
"type": "object",
"title": "Deployment Style",
"description": "Information about the type of deployment"
},
"autoScalingGroups": {
"type": "array",
"title": "Auto Scaling Groups",
"description": "A list of associated Auto Scaling groups",
"items": {
"type": "object"
}
},
"loadBalancerInfo": {
"type": "object",
"title": "Load Balancer Info",
"description": "Information about the load balancer used in the deployment"
},
"outdatedInstancesStrategy": {
"type": "string",
"title": "Outdated Instances Strategy",
"description": "Indicates what happens when new Amazon EC2 instances are launched",
"enum": [
"UPDATE",
"IGNORE"
]
},
"tags": {
"type": "array",
"title": "Tags",
"description": "The metadata tags associated with the deployment group",
"items": {
"type": "object"
}
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodeDeploy::DeploymentGroup
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.DeploymentGroupId
title: .Properties.ApplicationName + "/" + .Properties.DeploymentGroupName
blueprint: '"codedeployDeploymentGroup"'
properties:
applicationName: .Properties.ApplicationName
deploymentGroupId: .Properties.DeploymentGroupId
serviceRoleArn: .Properties.ServiceRoleArn
computePlatform: .Properties.ComputePlatform
deploymentStyle: .Properties.DeploymentStyle
autoScalingGroups: .Properties.AutoScalingGroups
loadBalancerInfo: .Properties.LoadBalancerInfo
outdatedInstancesStrategy: .Properties.OutdatedInstancesStrategy
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codeDeployDeployment",
"title": "CodeDeploy Deployment",
"icon": "AWS",
"schema": {
"properties": {
"deploymentId": {
"type": "string",
"title": "Deployment ID",
"description": "The unique ID of the deployment"
},
"applicationName": {
"type": "string",
"title": "Application Name",
"description": "The name of the application"
},
"deploymentGroupName": {
"type": "string",
"title": "Deployment Group",
"description": "The name of the deployment group"
},
"status": {
"type": "string",
"title": "Status",
"description": "The status of the deployment",
"enum": [
"Created",
"Queued",
"InProgress",
"Succeeded",
"Failed",
"Stopped",
"Ready"
]
},
"creator": {
"type": "string",
"title": "Creator",
"description": "The user who created the deployment"
},
"createTime": {
"type": "string",
"title": "Create Time",
"description": "The time the deployment was created",
"format": "date-time"
},
"startTime": {
"type": "string",
"title": "Start Time",
"description": "The time the deployment started",
"format": "date-time"
},
"completeTime": {
"type": "string",
"title": "Complete Time",
"description": "The time the deployment completed",
"format": "date-time"
},
"description": {
"type": "string",
"title": "Description",
"description": "A comment about the deployment"
},
"deploymentStyle": {
"type": "object",
"title": "Deployment Style",
"description": "Information about the type of deployment"
},
"region": {
"type": "string",
"title": "Region",
"description": "AWS region where the deployment is located"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodeDeploy::Deployment
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.DeploymentId
title: .Properties.ApplicationName + "/" + .Properties.DeploymentGroupName + "/" + .Properties.DeploymentId
blueprint: '"codeDeployDeployment"'
properties:
deploymentId: .Properties.DeploymentId
applicationName: .Properties.ApplicationName
deploymentGroupName: .Properties.DeploymentGroupName
status: .Properties.Status
creator: .Properties.Creator
createTime: .Properties.CreateTime
startTime: .Properties.StartTime
completeTime: .Properties.CompleteTime
description: .Properties.Description
deploymentStyle: .Properties.DeploymentStyle
region: .__ExtraContext.Region
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codedeployDeploymentTarget",
"title": "CodeDeploy Deployment Target",
"icon": "AWS",
"schema": {
"properties": {
"deploymentId": {
"type": "string",
"title": "Deployment ID",
"description": "The unique ID of the deployment"
},
"deploymentTargetType": {
"type": "string",
"title": "Deployment Target Type",
"description": "The deployment type that is specific to the deployment's compute platform",
"enum": [
"InstanceTarget",
"LambdaTarget",
"ECSTarget",
"CloudFormationTarget"
]
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodeDeploy::DeploymentTarget
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.DeploymentId + "/" + .Properties.TargetId
title: .Properties.DeploymentId + "/" + .Properties.TargetId
blueprint: '"codedeployDeploymentTarget"'
properties:
deploymentId: .Properties.DeploymentId
deploymentTargetType: .Properties.DeploymentTargetType
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codePipeline",
"title": "CodePipeline Pipeline",
"icon": "AWS",
"schema": {
"properties": {
"arn": {
"type": "string",
"title": "ARN",
"description": "The Amazon Resource Name (ARN) of the pipeline"
},
"roleArn": {
"type": "string",
"title": "Role ARN",
"description": "The service role ARN for the pipeline"
},
"executionMode": {
"type": "string",
"title": "Execution Mode",
"description": "The execution mode of the pipeline"
},
"pipelineType": {
"type": "string",
"title": "Pipeline Type",
"description": "The type of the pipeline"
},
"version": {
"type": "number",
"title": "Version",
"description": "The version number of the pipeline"
},
"stages": {
"type": "array",
"title": "Stages",
"description": "The stages of the pipeline",
"items": {
"type": "object"
}
},
"created": {
"type": "string",
"title": "Created",
"description": "The date when the pipeline was created",
"format": "date-time"
},
"updated": {
"type": "string",
"title": "Updated",
"description": "The date when the pipeline was last updated",
"format": "date-time"
},
"tags": {
"type": "array",
"title": "Tags",
"description": "Tags associated with the pipeline",
"items": {
"type": "object"
}
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodePipeline::Pipeline
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.PipelineArn
title: .Properties.Name
blueprint: '"codePipeline"'
properties:
arn: .Properties.PipelineArn
roleArn: .Properties.RoleArn
executionMode: .Properties.ExecutionMode
pipelineType: .Properties.PipelineType
version: .Properties.Version
stages: .Properties.Stages
created: .Properties.Created
updated: .Properties.Updated
tags: .Properties.Tags
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codePipelineStage",
"title": "CodePipeline Stage",
"icon": "AWS",
"schema": {
"properties": {
"pipelineName": {
"type": "string",
"title": "Pipeline Name",
"description": "The name of the CodePipeline pipeline this stage belongs to"
},
"pipelineArn": {
"type": "string",
"title": "Pipeline ARN",
"description": "The Amazon Resource Name (ARN) of the pipeline"
},
"actions": {
"type": "array",
"title": "Actions",
"description": "The list of actions that are part of this stage",
"items": {
"type": "object"
}
},
"name": {
"type": "string",
"title": "Name",
"description": "The name of the stage in the pipeline"
},
"order": {
"type": "number",
"title": "Order",
"description": "The sequential order of the stage within the pipeline"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodePipeline::Stage
selector:
query: 'true'
port:
entity:
mappings:
identifier: (.Properties.PipelineArn + "/" + .Properties.Name)
title: (.Properties.PipelineName + "/" + .Properties.Name)
blueprint: '"codePipelineStage"'
properties:
pipelineName: .Properties.PipelineName
pipelineArn: .Properties.PipelineArn
name: .Properties.Name
order: .Properties.Order
actions: .Properties.Actions
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codePipelineAction",
"title": "CodePipeline Action",
"icon": "AWS",
"schema": {
"properties": {
"name": {
"type": "string",
"title": "Name",
"description": "The name of the action"
},
"provider": {
"type": "string",
"title": "Provider",
"description": "The action provider (e.g., S3, CodeBuild, CodeDeploy)"
},
"category": {
"type": "string",
"title": "Category",
"description": "The action category (Source, Build, Deploy, etc.)"
},
"owner": {
"type": "string",
"title": "Owner",
"description": "The action owner (AWS, ThirdParty, Custom)"
},
"version": {
"type": "string",
"title": "Version",
"description": "The action version"
},
"runOrder": {
"type": "number",
"title": "Run Order",
"description": "The order in which the action runs"
},
"configuration": {
"type": "object",
"title": "Configuration",
"description": "Action configuration parameters"
},
"inputArtifacts": {
"type": "array",
"title": "Input Artifacts",
"description": "Input artifacts for the action",
"items": {
"type": "object"
}
},
"outputArtifacts": {
"type": "array",
"title": "Output Artifacts",
"description": "Output artifacts produced by the action",
"items": {
"type": "object"
}
},
"roleArn": {
"type": "string",
"title": "Role ARN",
"description": "The ARN of the role used for the action"
},
"region": {
"type": "string",
"title": "Region",
"description": "The region where the action runs"
},
"pipelineName": {
"type": "string",
"title": "Pipeline Name",
"description": "The name of the pipeline containing this action"
},
"stageName": {
"type": "string",
"title": "Stage Name",
"description": "The name of the stage containing this action"
},
"pipelineArn": {
"type": "string",
"title": "Pipeline ARN",
"description": "The ARN of the pipeline"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodePipeline::Action
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.PipelineArn + "/" + .Properties.StageName + "/" + .Properties.Name
title: .Properties.PipelineName + "/" + .Properties.StageName + "/" + .Properties.Name
blueprint: '"codePipelineAction"'
properties:
name: .Properties.Name
provider: .Properties.ActionTypeId.Provider
category: .Properties.ActionTypeId.Category
owner: .Properties.ActionTypeId.Owner
version: .Properties.ActionTypeId.Version
runOrder: .Properties.RunOrder
configuration: .Properties.Configuration
inputArtifacts: .Properties.InputArtifacts
outputArtifacts: .Properties.OutputArtifacts
roleArn: .Properties.RoleArn
region: .Properties.Region
pipelineName: .Properties.PipelineName
stageName: .Properties.StageName
pipelineArn: .Properties.PipelineArn
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codePipelinePipelineExecution",
"title": "CodePipeline Pipeline Execution",
"icon": "AWS",
"schema": {
"properties": {
"pipelineName": {
"type": "string",
"title": "Pipeline Name",
"description": "The name of the pipeline"
},
"pipelineVersion": {
"type": "number",
"title": "Pipeline Version",
"description": "The version of the pipeline definition"
},
"pipelineExecutionId": {
"type": "string",
"title": "Execution ID",
"description": "The unique identifier for the pipeline execution"
},
"status": {
"type": "string",
"title": "Status",
"description": "The status of the pipeline execution",
"enum": [
"InProgress",
"Stopped",
"Stopping",
"Succeeded",
"Superseded",
"Failed"
]
},
"statusSummary": {
"type": "string",
"title": "Status Summary",
"description": "A summary of the status of the pipeline execution"
},
"executionMode": {
"type": "string",
"title": "Execution Mode",
"description": "The execution mode for this pipeline execution",
"enum": [
"QUEUED",
"SUPERSEDED",
"PARALLEL"
]
},
"trigger": {
"type": "object",
"title": "Trigger",
"description": "The trigger that caused the pipeline execution"
},
"artifactRevisions": {
"type": "array",
"title": "Artifact Revisions",
"description": "A list of source code revisions for the pipeline execution",
"items": {
"type": "object"
}
},
"variables": {
"type": "array",
"items": {
"type": "object"
},
"title": "Variables",
"description": "Variables defined for the pipeline execution"
},
"lastUpdateTime": {
"type": "string",
"format": "date-time",
"title": "Last Update Time",
"description": "The time when the pipeline execution was last updated",
"dateFormat": "relative"
},
"startTime": {
"type": "string",
"format": "date-time",
"title": "StartTime",
"description": "The time when the pipeline execution started",
"dateFormat": "relative"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodePipeline::PipelineExecution
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.PipelineExecutionId
title: .Properties.PipelineName + "/" + .Properties.PipelineExecutionId
blueprint: '"codePipelinePipelineExecution"'
properties:
pipelineName: .Properties.PipelineName
pipelineVersion: .Properties.PipelineVersion
pipelineExecutionId: .Properties.PipelineExecutionId
status: .Properties.Status
statusSummary: .Properties.StatusSummary
executionMode: .Properties.ExecutionMode
trigger: .Properties.Trigger
artifactRevisions: .Properties.ArtifactRevisions
variables: .Properties.Variables
startTime: .Properties.StartTime
lastUpdateTime: .Properties.LastUpdateTime
relations:
account: .__ExtraContext.AccountId
{
"identifier": "codePipelineActionExecution",
"title": "CodePipeline Action Execution",
"icon": "AWS",
"schema": {
"properties": {
"actionExecutionId": {
"type": "string",
"title": "Action Execution ID",
"description": "The unique ID of the action execution"
},
"actionName": {
"type": "string",
"title": "Action Name",
"description": "The name of the action"
},
"stageName": {
"type": "string",
"title": "Stage Name",
"description": "The name of the stage containing the action"
},
"pipelineExecutionId": {
"type": "string",
"title": "Pipeline Execution ID",
"description": "The pipeline execution ID associated with this action execution"
},
"pipelineVersion": {
"type": "number",
"title": "Pipeline Version",
"description": "The version of the pipeline when the action was executed"
},
"status": {
"type": "string",
"title": "Status",
"description": "The status of the action execution",
"enum": [
"InProgress",
"Abandoned",
"Succeeded",
"Failed"
]
},
"startTime": {
"type": "string",
"title": "Start Time",
"description": "The start time of the action execution",
"format": "date-time"
},
"lastUpdateTime": {
"type": "string",
"title": "Last Update Time",
"description": "The last update time of the action execution",
"format": "date-time"
},
"input": {
"type": "object",
"title": "Input",
"description": "Input details for the action execution"
},
"output": {
"type": "object",
"title": "Output",
"description": "Output details for the action execution"
}
},
"required": []
},
"mirrorProperties": {},
"calculationProperties": {},
"aggregationProperties": {},
"relations": {
"account": {
"title": "Account",
"target": "awsAccount",
"required": false,
"many": false
}
}
}
resources:
- kind: AWS::CodePipeline::ActionExecution
selector:
query: 'true'
port:
entity:
mappings:
identifier: .Properties.ActionExecutionId
title: .Properties.ActionName + "/" + .Properties.ActionExecutionId
blueprint: '"codePipelineActionExecution"'
properties:
actionExecutionId: .Properties.ActionExecutionId
actionName: .Properties.ActionName
stageName: .Properties.StageName
pipelineExecutionId: .Properties.PipelineExecutionId
pipelineVersion: .Properties.PipelineVersion
status: .Properties.Status
startTime: .Properties.StartTime
lastUpdateTime: .Properties.LastUpdateTime
input: .Properties.Input
output: .Properties.Output
relations:
account: .__ExtraContext.AccountId
Resource and property reference
Refer to the resource and property reference page for details on available AWS resources, their properties, and mapping examples.