AWS CodeDeploy

AWS::CodeDeploy::Application

The following example demonstrates how to ingest your AWS CodeDeploy applications to Port.

CodeDeploy Application supported actions

The table below summarizes the available actions for ingesting AWS CodeDeploy Application resources in Port:

Action	Description	Type	Required AWS Permission
GetCodeDeployApplicationDetailsAction	Discover CodeDeploy applications and retrieve configuration details.	Default	codedeploy:ListApplications, codedeploy:BatchGetApplications
GetCodeDeployApplicationTagsAction	Retrieve tags for each CodeDeploy application.	Default	codedeploy:ListTagsForResource

All properties available by default

CodeDeploy applications expose their key properties, including tags, via the default actions.

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

CodeDeploy Application blueprint (click to expand)

{
  "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
    }
  }
}

CodeDeploy Application mapping configuration (click to expand)

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

AWS::CodeDeploy::DeploymentGroup

The following example demonstrates how to ingest your AWS CodeDeploy deployment groups to Port.

CodeDeploy Deployment Group supported actions

The table below summarizes the available actions for ingesting AWS CodeDeploy Deployment Group resources in Port:

Action	Description	Type	Required AWS Permission
GetDeploymentGroupDetailsAction	Discover deployment groups and retrieve configuration details such as compute platform and deployment style.	Default	codedeploy:ListApplications, codedeploy:ListDeploymentGroups, codedeploy:BatchGetDeploymentGroups
GetDeploymentGroupTags	Retrieve tags for each deployment group.	Optional	codedeploy:ListTagsForResource

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.

Discovery flow

The integration lists CodeDeploy applications first, then fetches deployment groups for each application.

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

CodeDeploy Deployment Group blueprint (click to expand)

{
  "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
    }
  }
}

CodeDeploy Deployment Group mapping configuration (click to expand)

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

AWS::CodeDeploy::Deployment

The following example demonstrates how to ingest your AWS CodeDeploy deployments to Port.

CodeDeploy Deployment supported actions

The table below summarizes the available actions for ingesting AWS CodeDeploy Deployment resources in Port:

Action	Description	Type	Required AWS Permission
ListDeploymentsAction	Discover deployment IDs in the region.	Default	codedeploy:ListDeployments
GetDeploymentAction	Retrieve detailed deployment data such as status, creator, and timing.	Default	codedeploy:GetDeployment

All properties available by default

CodeDeploy deployments expose their key properties via the default ListDeploymentsAction and GetDeploymentAction.

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

CodeDeploy Deployment blueprint (click to expand)

{
  "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
    }
  }
}

CodeDeploy Deployment mapping configuration (click to expand)

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

AWS::CodeDeploy::DeploymentTarget

The following example demonstrates how to ingest your AWS CodeDeploy deployment targets to Port.

CodeDeploy Deployment Target supported actions

The table below summarizes the available actions for ingesting AWS CodeDeploy Deployment Target resources in Port:

Action	Description	Type	Required AWS Permission
GetDeploymentTargetDetailsAction	Retrieve deployment target details for each deployment, including target type and platform-specific data.	Default	codedeploy:ListDeployments, codedeploy:ListDeploymentTargets, codedeploy:BatchGetDeploymentTargets

Discovery flow

The integration lists deployments first, then fetches targets for each deployment. Deployments that have not started are skipped.

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

CodeDeploy Deployment Target blueprint (click to expand)

{
  "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
    }
  }
}

CodeDeploy Deployment Target mapping configuration (click to expand)

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

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