Visualize and manage Git deployments

Implement with AI

Send this guide to your coding agent.

Prerequisite: Install Port MCP

Open in ClaudeOpen in CodexOpen in Cursor

Open plan mode. Implement this Port guide in my org via MCP:

https://docs.port.io/guides/all/visualize-and-manage-git-deployments

Goal: get the guide's core flow working end-to-end in my org; adapting it to fit my existing setup takes priority over matching the guide 1:1.

Plan:
1. Confirm MCP is connected, in the right org, with sufficient permissions.
2. Diff the guide's data model (blueprints, properties, relations, actions, agents, automations, integrations, secrets) against mine.
3. Propose adaptations for gaps, reusing existing blueprints/relations over guide-named duplicates.
4. Flag what needs a UI click, credential, or secret from me, testing MCP capability empirically before ruling anything out.
5. Stop on any blocker and give me options. Approving this plan authorizes the writes it lists; pause only for writes beyond what's listed.

Build:
- Extend blueprint schema additively when upserting; don't remove or overwrite existing properties, and treat type conflicts as a blocker, not an auto-fix.
- List any mock data in the plan, minimal and labeled mock; once approved, seed it without re-asking, and tell me what you seeded.
- For anything the guide writes downstream (e.g. a webhook target), use a real entity, not a mock.
- For pages/widgets, use the real page identifier from the app URL, not a guessed slug.
- When you hit a UI step confirmed (not assumed) unsupported via MCP, pause, give exact clicks, then resume via MCP.
- Validate and give links after each meaningful step (only a tool-returned URL, no guessed paths); don't proceed if the last run wasn't a success.

Done:
- Confirm the guide's expected output exists and runs in Port.
- Summarize adaptations, seeded data, what was mocked or skipped, remaining UI steps, and how to verify.

This guide demonstrates how to ingest, visualize, and manage GitHub and GitLab deployments in Port.

You will:

• Ingest GitHub workflow runs or GitLab pipelines into Port's software catalog.
• Create self-service actions to trigger, retry, and cancel deployments.
• Build a dashboard to monitor deployments and run actions.

GitHub

GitLab

Common use cases

• Monitor deployment status and health across repositories from one dashboard.
• Let platform teams run deployment operations through governed self-service actions.

Prerequisites

• Complete the onboarding process.

GitHub

• Install Port's GitHub integration.

GitLab

• Install Port's GitLab integration.

Set up data model

The deployment blueprints are not created automatically when you install the GitHub or GitLab integration. Create the blueprints for your provider before updating its mapping.

GitHub

Create the GitHub workflow blueprint

1. Go to the Builder page of your portal.

2. Click on + Blueprint.

3. Click on Edit JSON.

4. Copy and paste the following JSON configuration into the editor:

   GitHub workflow blueprint (Click to expand)

   {
     "identifier": "githubWorkflow",
     "title": "Workflow",
     "icon": "Github",
     "schema": {
       "properties": {
         "path": {
           "title": "Path",
           "type": "string"
         },
         "status": {
           "title": "Status",
           "type": "string",
           "enum": [
             "active",
             "deleted",
             "disabled_fork",
             "disabled_inactivity",
             "disabled_manually"
           ],
           "enumColors": {
             "active": "green",
             "deleted": "red"
           }
         },
         "createdAt": {
           "title": "Created at",
           "type": "string",
           "format": "date-time"
         },
         "updatedAt": {
           "title": "Updated at",
           "type": "string",
           "format": "date-time"
         },
         "deletedAt": {
           "title": "Deleted at",
           "type": "string",
           "format": "date-time"
         },
         "link": {
           "title": "Link",
           "type": "string",
           "format": "url"
         }
       },
       "required": []
     },
     "mirrorProperties": {},
     "calculationProperties": {},
     "relations": {
       "repository": {
         "title": "Repository",
         "target": "service",
         "required": false,
         "many": false
       }
     }
   }

5. Click Save to create the blueprint.

Create the GitHub workflow run blueprint

1. Go to the Builder page of your portal.

2. Click on + Blueprint.

3. Click on Edit JSON.

4. Copy and paste the following JSON configuration into the editor:

   GitHub workflow run blueprint (Click to expand)

   {
     "identifier": "githubWorkflowRun",
     "title": "Workflow Run",
     "icon": "Github",
     "schema": {
       "properties": {
         "name": {
           "title": "Name",
           "type": "string"
         },
         "triggeringActor": {
           "title": "Triggering actor",
           "type": "string"
         },
         "status": {
           "title": "Status",
           "type": "string",
           "enum": [
             "completed",
             "action_required",
             "cancelled",
             "startup_failure",
             "failure",
             "neutral",
             "skipped",
             "stale",
             "success",
             "timed_out",
             "in_progress",
             "queued",
             "requested",
             "waiting"
           ],
           "enumColors": {
             "queued": "yellow",
             "in_progress": "yellow",
             "success": "green",
             "failure": "red"
           }
         },
         "conclusion": {
           "title": "Conclusion",
           "type": "string",
           "enum": [
             "completed",
             "action_required",
             "cancelled",
             "startup_failure",
             "failure",
             "neutral",
             "skipped",
             "stale",
             "success",
             "timed_out",
             "in_progress",
             "queued",
             "requested",
             "waiting"
           ],
           "enumColors": {
             "queued": "yellow",
             "in_progress": "yellow",
             "success": "green",
             "failure": "red"
           }
         },
         "createdAt": {
           "title": "Created at",
           "type": "string",
           "format": "date-time"
         },
         "runStartedAt": {
           "title": "Run started at",
           "type": "string",
           "format": "date-time"
         },
         "updatedAt": {
           "title": "Updated at",
           "type": "string",
           "format": "date-time"
         },
         "runNumber": {
           "title": "Run number",
           "type": "number"
         },
         "runAttempt": {
           "title": "Run attempts",
           "type": "number"
         },
         "link": {
           "title": "Link",
           "type": "string",
           "format": "url"
         }
       },
       "required": []
     },
     "mirrorProperties": {},
     "calculationProperties": {},
     "relations": {
       "workflow": {
         "target": "githubWorkflow",
         "required": true,
         "many": false
       }
     }
   }

5. Click Save to create the blueprint.

GitLab

Create the GitLab pipeline blueprint

1. Go to the Builder page of your portal.

2. Click on + Blueprint.

3. Click on Edit JSON.

4. Copy and paste the following JSON configuration into the editor:

   GitLab pipeline blueprint (Click to expand)

   {
     "identifier": "gitlabPipeline",
     "title": "GitLab Pipeline",
     "icon": "GitLab",
     "schema": {
       "properties": {
         "createdAt": {
           "type": "string",
           "title": "Created at",
           "format": "date-time",
           "description": "When the pipeline was created"
         },
         "updatedAt": {
           "type": "string",
           "title": "Updated at",
           "format": "date-time",
           "description": "When the pipeline was last updated"
         },
         "link": {
           "type": "string",
           "title": "Link",
           "format": "url",
           "description": "URL to the pipeline in GitLab"
         },
         "status": {
           "type": "string",
           "title": "Status",
           "enum": [
             "failed",
             "success",
             "canceled"
           ],
           "enumColors": {
             "failed": "red",
             "success": "green",
             "canceled": "darkGray"
           }
         },
         "targetBranch": {
           "type": "string",
           "title": "Branch"
         }
       },
       "required": []
     },
     "mirrorProperties": {},
     "calculationProperties": {},
     "aggregationProperties": {},
     "relations": {
       "project": {
         "title": "Project",
         "target": "service",
         "required": false,
         "many": false
       }
     }
   }

5. Click Save to create the blueprint.

Update integration mapping

Configure your provider integration to ingest the deployment entities represented by the blueprints.

GitHub

Update GitHub mapping

1. In your GitHub repository, create or update port-app-config.yml.

2. Add the following configuration to ingest repositories, workflows, and workflow runs:

   GitHub integration configuration (Click to expand)

   resources:
     - kind: repository
       selector:
         query: "true"
         includedFiles:
           - README.md
       port:
         entity:
           mappings:
             identifier: .name
             title: .name
             blueprint: '"service"'
             properties:
               readme: .__includedFiles["README.md"]
               url: .html_url
               defaultBranch: .default_branch
     - kind: workflow
       selector:
         query: "true"
       port:
         entity:
           mappings:
             identifier: ".__repository + (.id | tostring)"
             title: .name
             blueprint: '"githubWorkflow"'
             properties:
               path: .path
               status: .state
               createdAt: .created_at
               updatedAt: .updated_at
               link: .html_url
             relations:
               repository: ".__repository"
     - kind: workflow-run
       selector:
         query: "true"
       port:
         entity:
           mappings:
             identifier: ".repository.name + \"/\" + (.id | tostring)"
             title: .display_title
             blueprint: '"githubWorkflowRun"'
             properties:
               name: .name
               triggeringActor: .triggering_actor.login
               status: .status
               conclusion: .conclusion
               createdAt: .created_at
               runStartedAt: .run_started_at
               updatedAt: .updated_at
               runNumber: .run_number
               runAttempt: .run_attempt
               link: .html_url
             relations:
               workflow: ".repository.name + (.workflow_id | tostring)"

3. Commit and push port-app-config.yml. The GitHub integration will sync the workflows and workflow runs automatically.

GitLab

Update GitLab mapping

1. Go to the Data sources page of your portal.

2. Select your GitLab integration.

3. Add the following YAML block into the editor:

   GitLab integration configuration (Click to expand)

   deleteDependentEntities: true
   createMissingRelatedEntities: true
   enableMergeEntity: true
   resources:
     - kind: project
       selector:
         query: "true"
         includeLanguages: true
       port:
         entity:
           mappings:
             identifier: .id | tostring
             title: .name
             blueprint: '"service"'
             properties:
               url: .web_url
               readme: file://README.md
               language: .__languages | to_entries | max_by(.value) | .key
     - kind: pipeline
       selector:
         query: "true"
       port:
         entity:
           mappings:
             identifier: .id | tostring
             title: (.project_id | tostring) + "-" + (.id | tostring)
             blueprint: '"gitlabPipeline"'
             properties:
               status: .status
               createdAt: .created_at
               updatedAt: .updated_at
               targetBranch: .ref
               link: .web_url
             relations:
               project: .project_id | tostring

4. Click Save & Resync to apply the mapping.

Set up self-service actions

Create three synced-webhook actions for your provider: trigger a deployment, retry a failed deployment, and cancel a running deployment.

GitHub

Add Port secret

Add a GitHub token that Port can use to call the GitHub Actions API:

1. In Port, click on your profile picture .

2. Click on Credentials.

3. Click on the Secrets tab.

4. Click on + Secret and add _GITHUB_TOKEN. Use a fine-grained personal access token with Actions: Read and write repository permission.

Trigger

Set up self-service action

This action starts the selected GitHub workflow on the main branch and passes the chosen environment as a workflow input.

1. Go to the Self-service page of your portal.

2. Click on the + New Action button.

3. Click on the {...} Edit JSON button.

4. Copy and paste the following JSON configuration into the editor:

   Trigger a GitHub workflow run (Click to expand)

   Replace the GitHub organization

   Replace <YOUR_GITHUB_ORG> in the webhook URL with your GitHub organization name.

   {
     "identifier": "trigger_workflow_run",
     "title": "Trigger workflow run",
     "icon": "Github",
     "description": "Trigger a GitHub workflow run in the selected repository",
     "trigger": {
       "type": "self-service",
       "operation": "DAY-2",
       "userInputs": {
         "properties": {
           "environment": {
             "icon": "DefaultProperty",
             "title": "Environment",
             "type": "string",
             "default": "test",
             "enum": [
               "test",
               "staging",
               "production"
             ],
             "enumColors": {
               "test": "lightGray",
               "staging": "lightGray",
               "production": "lightGray"
             }
           }
         },
         "required": [],
         "order": [
           "environment"
         ]
       },
       "blueprintIdentifier": "githubWorkflow"
     },
     "invocationMethod": {
       "type": "WEBHOOK",
       "url": "https://api.github.com/repos/<YOUR_GITHUB_ORG>/{{ .entity.relations.repository }}/actions/workflows/{{ .entity.properties.path | split(\"/\")[-1] }}/dispatches",
       "agent": false,
       "synchronized": true,
       "method": "POST",
       "headers": {
         "Accept": "application/vnd.github+json",
         "Authorization": "Bearer {{ .secrets._GITHUB_TOKEN }}",
         "X-GitHub-Api-Version": "2022-11-28",
         "Content-Type": "application/json"
       },
       "body": {
         "ref": "main",
         "inputs": {
           "environment": "{{ .inputs.environment }}"
         }
       }
     },
     "requiredApproval": false
   }

5. Click Save to create the action.

The Trigger workflow run action now appears for entities based on the GitHub Workflow blueprint.

Retry

Set up self-service action

This action retries the failed jobs in a GitHub workflow run whose conclusion is failure or cancelled.

1. Go to the Self-service page of your portal.

2. Click on the + New Action button.

3. Click on the {...} Edit JSON button.

4. Copy and paste the following JSON configuration into the editor:

   Retry a GitHub workflow run (Click to expand)

   Replace the GitHub organization

   Replace <YOUR_GITHUB_ORG> in the webhook URL with your GitHub organization name.

   {
     "identifier": "rerun_workflow_run",
     "title": "Re-run workflow run",
     "icon": "Pipeline",
     "description": "Re-run failed or cancelled jobs in a GitHub workflow run",
     "trigger": {
       "type": "self-service",
       "operation": "DAY-2",
       "userInputs": {
         "properties": {},
         "required": [],
         "order": []
       },
       "condition": {
         "type": "SEARCH",
         "rules": [
           {
             "property": "conclusion",
             "operator": "in",
             "value": [
               "failure",
               "cancelled"
             ]
           }
         ],
         "combinator": "and"
       },
       "blueprintIdentifier": "githubWorkflowRun"
     },
     "invocationMethod": {
       "type": "WEBHOOK",
       "url": "https://api.github.com/repos/<YOUR_GITHUB_ORG>/{{ .entity.identifier | split(\"/\")[0] }}/actions/runs/{{ .entity.identifier | split(\"/\")[-1] }}/rerun-failed-jobs",
       "agent": false,
       "synchronized": true,
       "method": "POST",
       "headers": {
         "Accept": "application/vnd.github+json",
         "Authorization": "Bearer {{ .secrets._GITHUB_TOKEN }}",
         "X-GitHub-Api-Version": "2022-11-28"
       }
     },
     "requiredApproval": false
   }

5. Click Save to create the action.

The Re-run workflow run action now appears on failed or cancelled GitHub Workflow Run entities.

Cancel

Set up self-service action

This action cancels the selected GitHub workflow run.

1. Go to the Self-service page of your portal.

2. Click on the + New Action button.

3. Click on the {...} Edit JSON button.

4. Copy and paste the following JSON configuration into the editor:

   Cancel a GitHub workflow run (Click to expand)

   Replace the GitHub organization

   Replace <YOUR_GITHUB_ORG> in the webhook URL with your GitHub organization name.

   {
     "identifier": "cancel_workflow_run",
     "title": "Cancel workflow run",
     "icon": "Unavailable",
     "description": "Cancel a running GitHub workflow run",
     "trigger": {
       "type": "self-service",
       "operation": "DAY-2",
       "userInputs": {
         "properties": {},
         "required": [],
         "order": []
       },
       "blueprintIdentifier": "githubWorkflowRun"
     },
     "invocationMethod": {
       "type": "WEBHOOK",
       "url": "https://api.github.com/repos/<YOUR_GITHUB_ORG>/{{ .entity.identifier | split(\"/\")[0] }}/actions/runs/{{ .entity.identifier | split(\"/\")[-1] }}/cancel",
       "agent": false,
       "synchronized": true,
       "method": "POST",
       "headers": {
         "Accept": "application/vnd.github+json",
         "Authorization": "Bearer {{ .secrets._GITHUB_TOKEN }}",
         "X-GitHub-Api-Version": "2022-11-28"
       }
     },
     "requiredApproval": false
   }

5. Click Save to create the action.

The Cancel workflow run action now appears on GitHub Workflow Run entities.

GitLab

Add Port secrets

Add the credentials that Port needs for the GitLab pipeline APIs:

1. In Port, click on your profile picture .

2. Click on Credentials.

3. Click on the Secrets tab.

4. Click on + Secret and add:

   • GITLAB_TRIGGER_TOKEN - A pipeline trigger token used to start pipelines.
   • GITLAB_API_TOKEN - A GitLab access token with the api scope, used to retry and cancel pipelines.

Trigger

Set up self-service action

This action starts a pipeline on the selected GitLab project's main branch and passes the chosen environment as a pipeline variable.

1. Go to the Self-service page of your portal.

2. Click on the + New Action button.

3. Click on the {...} Edit JSON button.

4. Copy and paste the following JSON configuration into the editor:

   Trigger a GitLab pipeline (Click to expand)

   {
     "identifier": "trigger_pipeline",
     "title": "Trigger pipeline",
     "icon": "GitLab",
     "description": "Trigger a GitLab pipeline in the selected project",
     "trigger": {
       "type": "self-service",
       "operation": "DAY-2",
       "userInputs": {
         "properties": {
           "environment": {
             "icon": "DefaultProperty",
             "title": "Environment",
             "type": "string",
             "default": "test",
             "enum": [
               "test",
               "staging",
               "production"
             ],
             "enumColors": {
               "test": "lightGray",
               "staging": "lightGray",
               "production": "lightGray"
             }
           }
         },
         "required": [],
         "order": [
           "environment"
         ]
       },
       "blueprintIdentifier": "service"
     },
     "invocationMethod": {
       "type": "WEBHOOK",
       "url": "https://gitlab.com/api/v4/projects/{{ .entity.identifier }}/trigger/pipeline?token={{ .secrets.GITLAB_TRIGGER_TOKEN }}&ref=main",
       "agent": false,
       "synchronized": true,
       "method": "POST",
       "headers": {
         "RUN_ID": "{{ .run.id }}",
         "Content-Type": "application/json"
       },
       "body": {
         "variables": {
           "environment": "{{ .inputs.environment }}"
         }
       }
     },
     "requiredApproval": false
   }

5. Click Save to create the action.

The Trigger pipeline action now appears on entities based on the Service blueprint.

Retry

Set up self-service action

This action retries failed or canceled jobs in the selected GitLab pipeline.

1. Go to the Self-service page of your portal.

2. Click on the + New Action button.

3. Click on the {...} Edit JSON button.

4. Copy and paste the following JSON configuration into the editor:

   Retry a GitLab pipeline (Click to expand)

   {
     "identifier": "retry_pipeline",
     "title": "Retry pipeline",
     "icon": "Pipeline",
     "description": "Retry failed or canceled jobs in a GitLab pipeline",
     "trigger": {
       "type": "self-service",
       "operation": "DAY-2",
       "userInputs": {
         "properties": {},
         "required": [],
         "order": []
       },
       "condition": {
         "type": "SEARCH",
         "rules": [
           {
             "property": "status",
             "operator": "in",
             "value": [
               "failed",
               "canceled"
             ]
           }
         ],
         "combinator": "and"
       },
       "blueprintIdentifier": "gitlabPipeline"
     },
     "invocationMethod": {
       "type": "WEBHOOK",
       "url": "https://gitlab.com/api/v4/projects/{{ .entity.relations.project }}/pipelines/{{ .entity.identifier }}/retry",
       "agent": false,
       "synchronized": true,
       "method": "POST",
       "headers": {
         "RUN_ID": "{{ .run.id }}",
         "Content-Type": "application/json",
         "PRIVATE-TOKEN": "{{ .secrets.GITLAB_API_TOKEN }}"
       }
     },
     "requiredApproval": false
   }

5. Click Save to create the action.

The Retry pipeline action now appears on failed or canceled GitLab Pipeline entities.

Cancel

Set up self-service action

This action cancels all running jobs in the selected GitLab pipeline.

1. Go to the Self-service page of your portal.

2. Click on the + New Action button.

3. Click on the {...} Edit JSON button.

4. Copy and paste the following JSON configuration into the editor:

   Cancel a GitLab pipeline (Click to expand)

   {
     "identifier": "cancel_pipeline",
     "title": "Cancel pipeline",
     "icon": "Unavailable",
     "description": "Cancel all running jobs in a GitLab pipeline",
     "trigger": {
       "type": "self-service",
       "operation": "DAY-2",
       "userInputs": {
         "properties": {},
         "required": [],
         "order": []
       },
       "blueprintIdentifier": "gitlabPipeline"
     },
     "invocationMethod": {
       "type": "WEBHOOK",
       "url": "https://gitlab.com/api/v4/projects/{{ .entity.relations.project }}/pipelines/{{ .entity.identifier }}/cancel",
       "agent": false,
       "synchronized": true,
       "method": "POST",
       "headers": {
         "RUN_ID": "{{ .run.id }}",
         "Content-Type": "application/json",
         "PRIVATE-TOKEN": "{{ .secrets.GITLAB_API_TOKEN }}"
       }
     },
     "requiredApproval": false
   }

5. Click Save to create the action.

The Cancel pipeline action now appears on GitLab Pipeline entities.

Visualize deployments

With deployment entities ingested and actions configured, create a dashboard to monitor deployment health and run remediation actions.

GitHub

Create the GitHub dashboard

1. Navigate to your software catalog.

2. Click on the + button in the left sidebar.

3. Select New dashboard.

4. Name the dashboard GitHub Deployment Manager.

5. Enter A dashboard to view, re-run, and cancel deployments in GitHub under Description.

6. Select the Github icon.

7. Click Create.

The dashboard is now ready for widgets that visualize GitHub workflow runs and expose the deployment actions.

Choose your deployment filter

This guide treats workflow runs as deployments when their titles contain deploy, CD, production, or staging. Adjust these filters to match your workflow naming conventions.

You can instead ingest GitHub's native deployment objects by mapping the deployment resource kind. See the GitHub deployment mapping example.

Add GitHub widgets

Add the following widgets to the dashboard:

Total deployments created in the last three months (Click to expand)

1. Click + Widget and select Number chart.

2. Enter Total deployments under Title and select the Deployment icon.

3. Select Count entities as the Chart type and GitHub Workflow Run as the Blueprint.

4. Select count under Function.

5. Add the following JSON to the Additional filters editor:

   [
     {
       "combinator": "and",
       "rules": [
         {
           "property": "$title",
           "operator": "contains",
           "value": "deploy"
         },
         {
           "property": "createdAt",
           "operator": "between",
           "value": {
             "preset": "last3Months"
           }
         }
       ]
     }
   ]

6. Select custom as the Unit and enter deployments as the Custom unit.

7. Click Save.

Deployments by status (Click to expand)

1. Click + Widget and select Pie chart.

2. Enter Deployments by status under Title and select the Deployment icon.

3. Select GitHub Workflow Run as the Blueprint.

4. Select Conclusion under Breakdown by property.

5. Add the following JSON to the Additional filters editor:

   {
     "combinator": "or",
     "rules": [
       {
         "property": "$title",
         "operator": "contains",
         "value": "deploy"
       },
       {
         "property": "$title",
         "operator": "contains",
         "value": "production"
       },
       {
         "property": "$title",
         "operator": "contains",
         "value": "CD"
       },
       {
         "property": "$title",
         "operator": "contains",
         "value": "staging"
       }
     ]
   }

6. Click Save.

Trigger workflow run action (Click to expand)

1. Click + Widget and select Action card.

2. Select the Trigger workflow run action.

3. Click Save.

All GitHub deployments (Click to expand)

1. Click + Widget and select Table.

2. Enter All deployments under Title.

3. Select GitHub Workflow Run as the Blueprint.

4. Add the following JSON to the Additional filters editor:

   {
     "combinator": "or",
     "rules": [
       {
         "property": "$title",
         "operator": "contains",
         "value": "deploy"
       },
       {
         "property": "$title",
         "operator": "contains",
         "value": "production"
       },
       {
         "property": "$title",
         "operator": "contains",
         "value": "CD"
       },
       {
         "property": "$title",
         "operator": "contains",
         "value": "staging"
       }
     ]
   }

5. Click Save to add the widget.

6. Click on the ... button in the top-right corner of the table and select Customize table.

7. Click Manage properties and add:

   • Conclusion - The conclusion of the workflow run.
   • Link - The URL of the workflow run.
   • Created at - The date when GitHub created the workflow run.
   • Run number - The workflow run number.
   • Run attempts - The number of attempts for the workflow run.

8. Click the save icon to save the customized table.

GitLab

Create the GitLab dashboard

1. Navigate to your software catalog.

2. Click on the + button in the left sidebar.

3. Select New dashboard.

4. Name the dashboard GitLab Deployment Manager.

5. Enter A dashboard to view, retry, and cancel deployments in GitLab under Description.

6. Select the GitLab icon.

7. Click Create.

The dashboard is now ready for widgets that visualize GitLab pipelines and expose the deployment actions. This guide treats pipelines created against the main branch as deployments.

Add GitLab widgets

Add the following widgets to the dashboard:

Total deployments created in the last three months (Click to expand)

1. Click + Widget and select Number chart.

2. Enter Total deployments under Title and select the Deployment icon.

3. Select Count entities as the Chart type and GitLab Pipeline as the Blueprint.

4. Select count under Function.

5. Add the following JSON to the Additional filters editor:

   [
     {
       "combinator": "and",
       "rules": [
         {
           "property": "targetBranch",
           "operator": "=",
           "value": "main"
         },
         {
           "property": "createdAt",
           "operator": "between",
           "value": {
             "preset": "last3Months"
           }
         }
       ]
     }
   ]

6. Select custom as the Unit and enter deployments as the Custom unit.

   

7. Click Save.

Deployments by status (Click to expand)

1. Click + Widget and select Pie chart.

2. Enter Deployments by state under Title and select the Deployment icon.

3. Select GitLab Pipeline as the Blueprint.

4. Select Status under Breakdown by property.

5. Add the following JSON to the Additional filters editor:

   {
     "combinator": "and",
     "rules": [
       {
         "property": "targetBranch",
         "operator": "=",
         "value": "main"
       },
       {
         "operator": "=",
         "value": "gitlabPipeline",
         "property": "$blueprint"
       }
     ]
   }

   

6. Click Save.

Trigger pipeline action (Click to expand)

1. Click + Widget and select Action card.

2. Select the Trigger pipeline action.

   

3. Click Save.

All GitLab deployments (Click to expand)

1. Click + Widget and select Table.

2. Enter All deployments under Title.

3. Select GitLab Pipeline as the Blueprint.

4. Add the following JSON to the Additional filters editor:

   {
     "combinator": "and",
     "rules": [
       {
         "property": "targetBranch",
         "operator": "=",
         "value": "main"
       },
       {
         "operator": "=",
         "value": "gitlabPipeline",
         "property": "$blueprint"
       }
     ]
   }

   

5. Click Save to add the widget.

6. Click on the ... button in the top-right corner of the table and select Customize table.

7. Click Manage properties and add:

   • Status - The pipeline status.
   • Link - The URL of the pipeline.
   • Branch - The pipeline's target branch.
   • Created at - The date when GitLab created the pipeline.
   • Repository - The related GitLab project.

8. Click the save icon to save the customized table.

Let's test it!

GitHub

1. Open the GitHub Deployment Manager dashboard.

2. Confirm that recent deployment workflow runs appear in the widgets.

3. Run the Trigger workflow run action and confirm that GitHub starts the workflow.

4. Open an eligible workflow run and test the Re-run workflow run or Cancel workflow run action.

5. Resync the GitHub integration and confirm that Port reflects the updated workflow run status.

GitLab

1. Open the GitLab Deployment Manager dashboard.

2. Confirm that recent main branch pipelines appear in the widgets.

3. Run the Trigger pipeline action and confirm that GitLab starts the pipeline.

4. Open an eligible pipeline and test the Retry pipeline or Cancel pipeline action.

5. Resync the GitLab integration and confirm that Port reflects the updated pipeline status.