Port

https://docs.port.io/
Admin
Port is a no-code internal developer portal that provides a single pane of glass for managing all...
Tokens:3,847,122
Snippets:21,578
Trust Score:8.2
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Start n8n with npm

Source: https://docs.port.io/context-lake/consuming-the-lake/other-consumption-methods/port-n8n-node

Starts the n8n instance after installation. Access the UI at http://localhost:5678.

```bash
n8n start  
```

--------------------------------

### Create backend repository from template

Source: https://docs.port.io/guides/all/manage-your-eks-clusters

Creates a private copy of the port-labs/eks-deploy-guide starter repository and prepares the directory structure for GitHub Actions workflows and Upbound cluster configuration files.

```bash
gh repo create <GITHUB_ORG>/<GITHUB_REPO> --private --clone \
  --template port-labs/eks-deploy-guide
cd <GITHUB_REPO>
mkdir -p .github/workflows .up/clusters .up/examples
```

--------------------------------

### Get MCP OAuth token with curl

Source: https://docs.port.io/agent-management/port-mcp-server/installation?mcp-setup=cursor

Request a token from the MCP OAuth endpoint for machine authentication in automated environments like CI/CD pipelines. Requires your client ID and client secret. For complete examples and detailed setup, refer to the machine authentication guide.

```bash
curl -X POST "https://mcp.port.io/v1/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials" \
  -d "client_id=YOUR_CLIENT_ID" \
  -d "client_secret=YOUR_CLIENT_SECRET"
```

--------------------------------

### Get entity - JavaScript

Source: https://docs.port.io/context-lake/ingestion/ingest-data-into-port/api/ingest-via-api-overview

JavaScript example using axios to authenticate and fetch an entity. Requires installing axios. The entity is available in getResponse.data.entity.

```javascript
// Dependencies to install:  

// $ npm install axios --save  

  

const axios = require("axios").default;  

  

const CLIENT_ID = "YOUR_CLIENT_ID";  

const CLIENT_SECRET = "YOUR_CLIENT_SECRET";  

  

const API_URL = "https://api.port.io/v1";  

  

(async () => {  

  const response = await axios.post(`${API_URL}/auth/access_token`, {  

    clientId: CLIENT_ID,  

    clientSecret: CLIENT_SECRET,  

  });  

  

  const accessToken = response.data.accessToken;  

  

  // You can now use the value in accessToken when making further requests  

  

  const blueprintId = "MY_BLUEPRINT";  

  const entityId = "MY_ENTITY_IDENTIFIER";  

  

  const config = {  

    headers: {  

      Authorization: `Bearer ${accessToken}`,  

    },  

  };  

  

  const getResponse = await axios.get(  

    `${API_URL}/blueprints/${blueprintId}/entities/${entityId}`,  

    config  

  );  

  

  // Entity is in getResponse.data.entity  

})();  

  
```

--------------------------------

### Get entity - cURL

Source: https://docs.port.io/context-lake/ingestion/ingest-data-into-port/api/ingest-via-api-overview

cURL example using jq to extract the access token and then fetch an entity. Requires jq to be installed. The entity can be read with jq '.entity'.

```bash
# Dependencies to install:  

# for brew:  

# brew install jq  

# For apt:  

# $ sudo apt-get install jq  

# For yum:  

# $ sudo yum install jq  

  

access_token=$(curl --location --request POST 'https://api.port.io/v1/auth/access_token' \  

--header 'Content-Type: application/json' \  

--data-raw '{  

    "clientId": "CLIENT_ID",  

    "clientSecret": "CLIENT_SECRET"  

}' | jq '.accessToken' | sed 's/"//g')  

  

# The token will be available in the access_token variable  

  

blueprint_id='MY_BLUEPRINT'  

entity_id='MY_ENTITY_IDENTIFIER'  

  

curl --location --request GET "https://api.port.io/v1/blueprints/${blueprint_id}/entities/${entity_id}" \  

    --header "Authorization: Bearer $access_token" \  

    --header "Content-Type: application/json"  

  

# Use jq '.entity' to read the entity  

  
```

--------------------------------

### Copy example environment file

Source: https://docs.port.io/guides/all/build-github-dashboards-in-port

Copies the example environment file to .env so you can configure it with your access keys.

```bash
cp .env.example .env  
```

--------------------------------

### Initialize Node.js project and install Express

Source: https://docs.port.io/workflows/actions-and-automations/setup-backend/webhook/local-debugging-webhook

Initializes a Node.js project and installs Express for the local webhook listener.

```bash
npm init -y  

npm install express  
```

--------------------------------

### Get entity - Python

Source: https://docs.port.io/context-lake/ingestion/ingest-data-into-port/api/ingest-via-api-overview

Python example using requests to authenticate and fetch an entity by blueprint and entity identifier. Requires installing the requests package. The entity is available in response.json()["entity"].

```python
# Dependencies to install:  

# $ python -m pip install requests  

  

import requests  

  

CLIENT_ID = 'YOUR_CLIENT_ID'  

CLIENT_SECRET = 'YOUR_CLIENT_SECRET'  

  

API_URL = 'https://api.port.io/v1'  

  

credentials = {'clientId': CLIENT_ID, 'clientSecret': CLIENT_SECRET}  

  

token_response = requests.post(f'{API_URL}/auth/access_token', json=credentials)  

  

access_token = token_response.json()['accessToken']  

  

# You can now use the value in access_token when making further requests  

  

headers = {  

    'Authorization': f'Bearer {access_token}'  

}  

  

blueprint_id = 'MY_BLUEPRINT'  

entity_id = 'MY_ENTITY_IDENTIFIER'  

  

response = requests.get(f'{API_URL}/blueprints/{blueprint_id}/entities/{entity_id}', headers=headers)  

  

# Entity is in response.json()["entity"]  

  
```

--------------------------------

### C# HttpClient example for get all integrations

Source: https://docs.port.io/api-reference/get-all-integrations

C# example using HttpClient to call the get all integrations endpoint. Sends a GET request with an Authorization header and prints the response.

```csharp
var client = new HttpClient();  
var request = new HttpRequestMessage(HttpMethod.Get, "https://api.port.io/v1/integration");  
request.Headers.Add("Authorization", "<Authorization>");  
var response = await client.SendAsync(request);  
response.EnsureSuccessStatusCode();  
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

--------------------------------

### Example response for presenting a found skill

Source: https://docs.port.io/guides/all/setup-skills-registry

Example response from the assistant when a relevant published skill is found. It includes the skill name, description, publish status, scorecard level, the install command from the blueprint's cliInstall property, and a link to the source file.

```text
I found a skill in the registry that covers this: "api-smoke-testing" -
starts the dev server, discovers API routes from the codebase, hits every
endpoint, and reports which ones error out. It's published and scores
Silver on production readiness.

To install it:
npx skills add https://github.com/your-org/skills-registry/tree/main/skills/testing/api-smoke-testing

Source: https://github.com/your-org/skills-registry/blob/main/skills/testing/api-smoke-testing/SKILL.md
```

--------------------------------

### Get All Blueprints - Response Example

Source: https://docs.port.io/api-reference/get-all-blueprints

Example response body for the Get All Blueprints endpoint. Shows the structure of a blueprint object, including identifier, title, schema, relations, and changelog destination.

```json
{
  "blueprints": [
    {
      "identifier": "string",
      "title": "string",
      "description": "string",
      "icon": "string",
      "ownership": {
        "type": "Inherited",
        "path": "string",
        "title": "string"
      },
      "schema": {
        "properties": {},
        "required": [
          "string"
        ]
      },
      "calculationProperties": {},
      "mirrorProperties": {},
      "aggregationProperties": {},
      "relations": {},
      "includeInGlobalSearch": true,
      "changelogDestination": {
        "type": "WEBHOOK",
        "agent": true,
        "url": "string"
      },
      "updatedBy": "string",
      "createdBy": "string",
      "createdAt": "2024-07-29T15:51:28.071Z",
      "updatedAt": "2024-07-29T15:51:28.071Z"
    }
  ]
}
```

--------------------------------

### Promote with export, import, or migrate

Source: https://docs.port.io/platform-administration/multi-org-management/manage-port-across-environments

Promote configuration by exporting from the source org, importing<｜image｜> the target, or migrating in one step. After promotion, run `port compare` again to confirm the target matches.

```bash
port export --output staging-config.tar.gz --org staging  
port import --input staging-config.tar.gz --org production  
port migrate --source-org staging --target-org production  
```

--------------------------------

### Terraform init, plan, and apply commands

Source: https://docs.port.io/guides/all/create-cloud-resource-using-iac

Commands to initialize Terraform, inspect the planned changes, create the infrastructure, and update Port. Run these after creating the main.tf file.

```bash
terraform init  
terraform plan  
terraform apply  

```

--------------------------------

### C# example: HttpClient GET request

Source: https://docs.port.io/api-reference/get-an-action-runs-details

C# code example using HttpClient to send a GET request to the action run details endpoint. Requires the Authorization header with a bearer token.

```csharp
var client = new HttpClient();  
var request = new HttpRequestMessage(HttpMethod.Get, "https://api.port.io/v1/actions/runs/:run_id");  
request.Headers.Add("Accept", "application/json");  
request.Headers.Add("Authorization", "<Authorization>");  
var response = await client.SendAsync(request);  
response.EnsureSuccessStatusCode();  
Console.WriteLine(await response.Content.ReadAsStringAsync());  
```

--------------------------------

### Install Boto3

Source: https://docs.port.io/context-lake/ingestion/ingest-data-into-port/other/s3-integrations

Install the Boto3 library using pip.

```bash
pip install boto3
```

--------------------------------

### C# example

Source: https://docs.port.io/api-reference/get-a-scorecard

C# code example using HttpClient to send a GET request to the scorecard endpoint.

```csharp
var client = new HttpClient();  
var request = new HttpRequestMessage(HttpMethod.Get, "https://api.port.io/v1/blueprints/:blueprint_identifier/scorecards/:scorecard_identifier");  
request.Headers.Add("Authorization", "<Authorization>");  
var response = await client.SendAsync(request);  
response.EnsureSuccessStatusCode();  
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

--------------------------------

### SKILL.md example with YAML frontmatter

Source: https://docs.port.io/agent-management/ai-registry/skills/overview?skill-examples=deployment

Example SKILL.md file with YAML frontmatter (name, description, metadata) followed by markdown instructions. The frontmatter must include name and description fields.

```markdown
---  

name: deploy-to-production  

description: Guide for deploying services to production. Use when users ask to deploy, release, or promote a service to production.  

metadata:  

  title: Deploy to Production  

---  

  

# Deploy to Production  

  

Follow these steps to deploy a service to production:  

  

## Step 1: Verify prerequisites  

- Check that all tests pass.  

- Verify the service has a production-readiness scorecard score above 80%.  

  

## Step 2: Run the deployment  

Execute the deployment action for the target service.  

  

## Common edge cases  

- If tests are failing, do not proceed with deployment.  

- If deployment fails, check logs and suggest rollback.  

```

--------------------------------

### Run incremental or full sync with make

Source: https://docs.port.io/guides/all/keep-azure-catalog-upto-date-with-incremental-syncing

Run the sync using make. Default is incremental; set SYNC_MODE=full for a full sync. Use a smaller CHANGE_WINDOW_MINUTES value during development for faster feedback.

```bash
# Incremental sync (default)  
make run  
  
# Full sync  
export SYNC_MODE=full  
make run  

```

--------------------------------

### Install n8n globally with npm

Source: https://docs.port.io/context-lake/consuming-the-lake/other-consumption-methods/port-n8n-node

Installs n8n globally using npm. Required before starting the n8n instance.

```bash
npm install n8n -g  
```

--------------------------------

### Set up integration mapping via Port API

Source: https://docs.port.io/guides/all/map-external-users-and-teams-to-port-accounts?integration=hibob

Use this script to set up the integration mapping via Port's API instead of the UI. It obtains an access token, optionally adds Git mirror properties to the Port User blueprint, and creates the workflow from the saved JSON file. Replace <YOUR_CLIENT_ID> and <YOUR_CLIENT_SECRET> with your credentials.

```bash
# Get an API access token  

PORT_TOKEN=$(curl -s -X POST "https://api.port.io/v1/auth/access_token" \  

  -H "Content-Type: application/json" \  

  -d '{"clientId": "<YOUR_CLIENT_ID>", "clientSecret": "<YOUR_CLIENT_SECRET>"}' | jq -r '.accessToken')  

  

# Optional: add the Git mirror properties to the Port User blueprint (merges with the existing blueprint)  

curl -s "https://api.port.io/v1/blueprints/_user" -H "Authorization: Bearer $PORT_TOKEN" | jq '.blueprint  

  | .mirrorProperties.github_login = {"title": "GitHub login", "path": "githubUser.login"}  

  | .mirrorProperties.gitlab_username = {"title": "GitLab username", "path": "gitlabUser.username"}  

  | .mirrorProperties.azuredevops_display_name = {"title": "Azure DevOps display name", "path": "azureDevopsUser.displayName"}' \  

  | curl -s -X PUT "https://api.port.io/v1/blueprints/_user" \  

      -H "Authorization: Bearer $PORT_TOKEN" -H "Content-Type: application/json" --data-binary @-  

  

# Create the workflow  

curl -s -X POST "https://api.port.io/v1/workflows" \  

  -H "Authorization: Bearer $PORT_TOKEN" -H "Content-Type: application/json" \  

  --data-binary @sync_port_user_for_git_users.json  


```

--------------------------------

### C# example using HttpClient

Source: https://docs.port.io/api-reference/get-all-teams-in-your-organization

Example C# code to send a GET request to the teams endpoint using HttpClient.

```csharp
var client = new HttpClient();  
var request = new HttpRequestMessage(HttpMethod.Get, "https://api.port.io/v1/teams");  
request.Headers.Add("Accept", "application/json");  
request.Headers.Add("Authorization", "<Authorization>");  
var response = await client.SendAsync(request);  
response.EnsureSuccessStatusCode();  
Console.WriteLine(await response.Content.ReadAsStringAsync());  

```

--------------------------------

### Install port-github-migrator tool

Source: https://docs.port.io/context-lake/ingestion/ingest-data-into-port/native-integrations/available-integrations/git/github-ocean/migration/migration-steps

Run this command to install the port-github-migrator tool via the install script. After installation, gather your Port API credentials: client ID, client secret, and instance URL.

```bash
curl -sL https://raw.githubusercontent.com/port-labs/port-github-migrator/main/install.sh | bash
```

--------------------------------

### Response schema example for GET /v1/teams

Source: https://docs.port.io/api-reference/get-all-teams-in-your-organization

Example JSON response for a successful request, showing the structure of the teams array.

```json
{  

  "teams": [  

    {  

      "id": "string",  

      "name": "string",  

      "createdAt": "2024-07-29T15:51:28.071Z",  

      "updatedAt": "2024-07-29T15:51:28.071Z",  

      "provider": "string",  

      "description": "string",  

      "users": [  

        {  

          "email": "string",  

          "firstName": "string",  

          "lastName": "string",  

          "picture": "string",  

          "status": "string"  

        }  

      ]  

    }  

  ]  

}  

```

--------------------------------

### C# HTTP client example

Source: https://docs.port.io/api-reference/get-a-scorecard-group-and-related-scorecards

C# example using HttpClient to send a GET request to the endpoint with the Authorization header.

```csharp
var client = new HttpClient();  
var request = new HttpRequestMessage(HttpMethod.Get, "https://api.port.io/v1/scorecard-groups/:scorecard_group_identifier");  
request.Headers.Add("Authorization", "<Authorization>");  
var response = await client.SendAsync(request);  
response.EnsureSuccessStatusCode();  
Console.WriteLine(await response.Content.ReadAsStringAsync());  

```

--------------------------------

### Install port-agent chart with configuration

Source: https://docs.port.io/workflows/actions-and-automations/setup-backend/webhook/port-execution-agent/installation-methods/helm

Installs the `port-agent` chart in the `port-agent` namespace. Replace the placeholders `YOUR_ORG_ID`, `YOUR_KAFKA_CONSUMER_GROUP`, `YOUR_PORT_CLIENT_ID`, and `YOUR_PORT_CLIENT_SECRET` with your actual values.

```bash
helm install my-port-agent port-labs/port-agent \  

    --create-namespace --namespace port-agent \  

    --set env.normal.PORT_ORG_ID=YOUR_ORG_ID \  

    --set env.normal.STREAMER_NAME=KAFKA \  

    --set env.normal.KAFKA_CONSUMER_GROUP_ID=YOUR_KAFKA_CONSUMER_GROUP \  

    --set env.secret.PORT_CLIENT_ID=YOUR_PORT_CLIENT_ID \  

    --set env.secret.PORT_CLIENT_SECRET=YOUR_PORT_CLIENT_SECRET  

```
Tokens:
Raw