AWS CodePipeline

AWS::CodePipeline::Pipeline

The following example demonstrates how to ingest your AWS CodePipeline pipelines to Port.

CodePipeline Pipeline supported actions

The table below summarizes the available actions for ingesting AWS CodePipeline Pipeline resources in Port:

Action	Description	Type	Required AWS Permission
ListPipelinesAction	Discover CodePipeline pipelines in the region.	Default	codepipeline:ListPipelines
GetPipelineDetailsAction	Retrieve detailed pipeline configuration such as stages, role ARN, and version.	Default	codepipeline:GetPipeline
GetPipelineTagsAction	Retrieve tags for each pipeline.	Default	codepipeline:ListTagsForResource

All properties available by default

CodePipeline pipelines expose their key properties, including tags, via the default actions.

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

CodePipeline Pipeline blueprint (click to expand)

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

CodePipeline Pipeline mapping configuration (click to expand)

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

AWS::CodePipeline::Stage

The following example demonstrates how to ingest your AWS CodePipeline stages to Port.

CodePipeline Stage supported actions

The table below summarizes the available actions for ingesting AWS CodePipeline Stage resources in Port:

Action	Description	Type	Required AWS Permission
GetPipelineStagesAction	Discover pipeline stages by expanding each pipeline definition into individual stage records.	Default	codepipeline:ListPipelines, codepipeline:GetPipeline

Discovery flow

The integration lists pipelines first, then expands each pipeline's stages array into separate stage entities with pipelineName, pipelineArn, and order metadata.

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

CodePipeline Stage blueprint (click to expand)

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

CodePipeline Stage mapping configuration (click to expand)

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

AWS::CodePipeline::Action

The following example demonstrates how to ingest your AWS CodePipeline actions to Port.

CodePipeline Action supported actions

The table below summarizes the available actions for ingesting AWS CodePipeline Action resources in Port:

Action	Description	Type	Required AWS Permission
GetPipelineActionsDetails	Discover pipeline actions by expanding each stage's actions array into individual action records.	Default	codepipeline:ListPipelines, codepipeline:GetPipeline

Discovery flow

The integration lists pipelines first, then expands each stage's actions into separate action entities with pipelineName, stageName, and pipelineArn metadata.

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

CodePipeline Action blueprint (click to expand)

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

CodePipeline Action mapping configuration (click to expand)

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

AWS::CodePipeline::PipelineExecution

The following example demonstrates how to ingest your AWS CodePipeline pipeline executions to Port.

CodePipeline Pipeline Execution supported actions

The table below summarizes the available actions for ingesting AWS CodePipeline Pipeline Execution resources in Port:

Action	Description	Type	Required AWS Permission
ListPipelineExecutionsAction	Discover pipeline execution summaries for each pipeline.	Default	codepipeline:ListPipelines, codepipeline:ListPipelineExecutions
GetPipelineExecutionDetailsAction	Retrieve detailed execution data such as status, trigger, and artifact revisions.	Default	codepipeline:GetPipelineExecution

Discovery flow

The integration lists pipelines first, then fetches executions for each pipeline.

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

CodePipeline Pipeline Execution blueprint (click to expand)

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

CodePipeline Pipeline Execution mapping configuration (click to expand)

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

AWS::CodePipeline::ActionExecution

The following example demonstrates how to ingest your AWS CodePipeline action executions to Port.

CodePipeline Action Execution supported actions

The table below summarizes the available actions for ingesting AWS CodePipeline Action Execution resources in Port:

Action	Description	Type	Required AWS Permission
ListActionExecutionsAction	Discover action executions for each pipeline in the region.	Default	codepipeline:ListPipelines, codepipeline:ListActionExecutions

Discovery flow

The integration lists pipelines first, then fetches action executions for each pipeline.

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

CodePipeline Action Execution blueprint (click to expand)

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

CodePipeline Action Execution mapping configuration (click to expand)

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

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