Changelog

Follow up on the latest improvements and updates.

RSS

It’s springtime, and along with the new flowers, leaves and the natural beauty of the season, Port re-branded. In case you haven’t noticed, check out the Port site or your Port developer portal. We also invested in letting you create personalized places for developers where they can easily see what needs to be done, and similar experiences for platform engineers modifying the data model.
Biggest
Brand new Port
↘️
We're excited to unveil Port's fresh rebranding. Here’s to our designers Val Burtakov and Ory Zydner, for better expressing what Port is all about, and creating a site and brand that we really love. Have a look.
logo
Change the data model directly in the software catalog
🗒️
Instead of working in the builder section of the portal, platform engineers can now make changes to the data model directly in the software catalog. You can now add and edit properties in catalog tables, making data model changes easy and immediately seeing how the changes will be seen by developers.
manageproperties-5
Medium
Add self-service action as a widget
With the new “Action Card” widget, you can now add self-service actions to your dashboards within its context, creating a holistic developer experience. For example, add a “Rollback Service” action to an incident management dashboard. This reduces context switching and helps make any insight immediately actionable. You can display one or more actions in one widget. Learn more.
Action_widget_(4)
Export data from table
You can now download a specific table view as a CSV or JSON file for further use.
Export_data
Small
Search in catalog pages
We’ve added a new sidebar search so you can easily find the catalog page you need.
search
Map each item from an array with
ItemsToParse
in Ocean integration
Create and update entities based on any array in an incoming event. Learn more
Gitlab Ocean integration - granular webhooks
The Gitlab Ocean integration now allows the creation of webhooks on specific groups and choosing which branch to listen to.
The biggest item in February’s release notes is Folders. Folders play a key role in realizing our portal-as-product approach, since they allow platform engineers to provide the right experience by developer, team, and manager. Folders let you group portal elements in a way that makes immediate sense to users and only provide them with what they need for a given use case. Additional items this month also focus on improving portal experiences, from the ability to add page and dashboard descriptions to action run status labels.
Biggest
Create developer experiences using Folders
📁
We are excited to announce the release of folders!
folders
  • Folders allow you to customize the Port sidebar, grouping portal elements by use case, persona, team, etc. By organizing your portal with folders, Port becomes a space that feels specifically designed for any developer workflow.
  • A folder can include dashboards, catalogs, or additional sub-folders up to three levels deep. This flexibility allows for a structured and clear organization of the portal's resources and should be done to simplify the portal for users.
  • You can expose users to specific folders by setting permissions for pages inside them.
Azure DevOps integration powered by Ocean
🔌
New integrations - February
This Ocean-powered integration makes it easier to integrate Azure DevOps by adding Projects, Repositories, Pull requests, Repository policies, Pipelines, Teams and Members to your catalog. Learn more.
---------------------------------------------------------
Medium
Quickly debug your integrations with live event logs
Live events
You can now view live event logs coming from Ocean integrations. These events contain valuable details for debugging your integration, such as the current status of the ocean container, resync process, and integration startup.
The new event log view is available for all Ocean integrations on the “Data sources” page.
Action run status label
statusLabel
You can now add a custom label to the action run status to reflect any step in the action process. These will be shown as part of the action run status card panel. Learn more.
Pages description
Page description
Add descriptions to pages and dashboards to make them easier to understand and search. Descriptions can be added when creating or editing the page or using the API.
Improvements in existing integrations and guides
  • K8s exporter - we reintroduced the ability to maintain your catalog data based on ConfigMap
  • SonarQube Ocean integration - we added support for on-premise analysis, leveraging PR and Measures API from SonarQube
  • Pagerduty Ocean integration - we added support for analytics on the service blueprint
  • BitBucket Server integration - our Python script now supports filtering specific projects to ingest from your Bitbucket environment
  • New cloud resources permissions guide - see this new comprehensive guide on how to implement IAM and Cloud resources in port
---------------------------------------------------------
Small
Load entity example when testing JQ
Page description
When testing JQ expression for a new calculation property, you can now load an existing entity example to test with real scenarios.
Actions and scorecards Audit Log
Audit log
See changes in actions and scorecards definitions using the Audit Log page.
User form Boolean input is now a toggle
toggle
For a better user form experience, we now support a toggle form input type. Note that “Select” input type is still available for cases where more than True/False is needed.
Terraform and Pulumi support for page permissions
You can now configure page permissions with IaC. See docs for Terraform or Pulumi.
New GitHub actions
  • You can now use our provided Github action to delete a Github repo
  • With the new Ocean Sail GitHub action, you can quickly and easily configure an Ocean integration to run as part of your GitHub workflow.
Biggest
image
Jenkins
visualize your CI/CD pipelines by adding views for Jenkins jobs, builds, and users. Install integration here. See docs here.
Wiz
provide developers and security engineers with a centralized view of their Wiz controls and issues. Install integration here. See docs here.
--------------------------------------------
Mediums
Improvements in existing integrations
  • All Ocean integrations now support installation using ArgoCD. Learn more.
  • Snyk - Added a new feature to auto-discover all groups and organizations associated with the Snyk ocean integration. Learn more.
  • ArgoCD - added support for ingesting ArgoCD deployment history into Port. Learn more.
  • Terraform cloud - added for support ingesting organization into Port. Learn more.
  • Kubernetes - added for support ingesting Kyverno policies into Port. Learn more.
  • AWS - added support for ingesting AWS ECR images into Port. Learn more.
  • AWS cost - added support for ingesting AWS cost using a GitLab Pipeline. Learn more.
  • JFrog - added support for ingesting artifacts and repositories into Port. Learn more.
  • GitHub - added support for ingesting GitHub users and GitHub packages into Port.
  • Bitbucket Server - use our script to easily ingest README.md files in every repository and display them in Port as a Markdown page.
Pre-made GitHub actions
Use these actions to create self-service actions for your developers - provision Azure resources, trigger Datadog incidents
--------------------------------------------
Smalls
JQ errors in the UI
image
To make it easy to debug issues when writing JQ, we now display JQ error messages when trying to test or save invalid JQ.
Enhanced search capability for tables
image
The table “free search” capability has improved and now supports searching each word separately instead of the entire search term.
JSON edit mode for self-service actions
image
When creating/editing self-service actions, you can now switch to “JSON mode” instead of the editing form.
Terraform provider enhancements
We enhanced the Terraform provider by adding support for - aggregation properties, and the “required” JQ setting for self-service actions.
Builder section is no longer in-view for Members
In order to create a more seamless experience for Port Members, the "Builder" tab is now hidden for them.
2023 was a breakout year for Port, and these release notes mark the end of a year that was spent making Port better, together with our community. Since opening the roadmap (see here) we’ve received numerous insights about what you need us to do in Port. In 2024 we hope to do more, better and faster, so that you can deliver exceptional developer experience and productivity using Port.
Biggest
Drive engineering standards across the organization with initiative & scorecard dashboards
📊
We added ready-made and easy-to-create dashboards so that you can simply track engineering scorecards and initiatives. Once defined, the dashboards will appear in the catalog section.
  1. Scorecard dashboards track the status and progress of an entire scorecard, such as production readiness, security, quality, etc.
  2. Initiative dashboards track the status and progress of specific scorecard rules.
Just like any other page in Port, you can customize these dashboards to your liking (such as adding/removing dashboard widgets) ✨
You can create these dashboards by clicking on the “New” button in the “Catalog” section.
Initiative dashboard
New dashboard
Visualize your Kubernetes runtime with the improved Kubernetes integration
🔌
We’ve improved Port’s Kubernetes integration and made it simpler with the following:
  1. The management of the integration configuration is now done via Port’s UI/API instead of saving a “Config.yaml” file in the Kubernetes cluster’s config map.
  2. Ability to resync the integration automatically after updating its configuration.
  3. Upon installing the integration, Port will automatically create several blueprints, pages, and dashboards out of the box, letting you easily get started visualizing your K8s with Port.
Kubernetes
View action run history with the action run widget
⚡️
The “Action run” widget allows you to display a table with the run history of a specific self-service action. This new widget can be added to any dashboard.
The widget will display as columns the general details of each run (ID, status, start, end) and also the specific inputs of the action that was filled by the user who executed it.
Action run
Widget
--------------------------------------------------------------------------------------------------
Mediums
New integrations
We have added more integrations that are powered by Ocean 🌊
  1. ServiceNow - incident management (install here, see docs here).
  2. Terraform Cloud - track infrastructure and run status (install here, see docs here).
Dynamic “Me” filter for table
When filtering a user property, you can now select the "Me" option in the "Has any of" operator to display only the entities with the logged-in user in the specific user property.
This is very useful when creating personalized views. For example, creating a personal on-call view containing only the services with the logged-in user in the "On-call" user property.
Filter
Delete and update default pages
When a new blueprint is created, a default catalog page is created automatically.
In some cases, these pages can clutter the catalog side menu. Previously, they couldn't be deleted, and now you can! We hope this change will help you build a more clean and intuitive catalog for users 👩‍💻
Note - you can always re-create pages by clicking the "New" button in the "Catalog" menu and clicking on the "New catalog page" button.
Delete page
--------------------------------------------------------------------------------------------------
Smalls
Manage action permissions using IaC
You can now manage self-service action permissions using IaC. See docs for Terraform & Pulumi.
GitLab integration - support system hooks
When an organization has a lot of projects/repositories, it can be difficult to create an Ocean deployment config that will automatically create the webhooks on all those projects.
Using “System” hooks, the GitLab integration will create a single webhook for the entire GitLab instance.
Export backup of your Port account
We created a handy script to help you easily back up your entire Port account (blueprints, entities, actions, scorecards, and teams).
Swagger UI property - Async API V3 Support
You can now display V3 Async API specification using the Swagger UI blueprint property type.
Async
Install Port integrations using ArgoCD
We’ve added documentation about how to install the following integrations using ArgoCD - Port self-service actions agent, Kubernetes, and any Ocean integration.
In this edition of Port’s release notes, we’re focused on making metrics and scorecards actionable and easy to use as well as customizing the developer experience ✨
Biggest
Calculate and view aggregated metrics
🔢
The new “Aggregation” property type for blueprints allows you to calculate metrics based on the relations in your catalog, supporting many aggregation types such as count, average, min, max, sum, and median.
Examples of aggregation properties for a microservice:
  1. Number of open Jira tickets.
  2. Number of open vulnerabilities.
  3. Average deployment frequency last week.
  4. Build success rate.
Aggregated metrics are also valuable for scorecards.
To create a new aggregation property, go to the “Builder” page → expand a blueprint → click on the “New property” button → choose the “Aggregation” property type.
Learn more about the aggregation property type here.
Aggregation
Build curated dashboards & homepages by controlling their layout
📊
Dashboards just become way more awesome! You can now fully control the dashboards and homepage layout by changing the location and size of the dashboard widgets, allowing you to curate views for the exact needs of your users for an optimized developer experience! 🚢
Dashboards layout
Create dynamic self-service action forms by controlling self-service input visibility and required settings
⚡️
When building a self-service action, you can now use the
visible
&
required
keys to dynamically hide/show inputs and set the “required” setting by creating conditions based on form inputs, action, and user data.
These two additions let you create sophisticated forms that support multiple scenarios and adapt to the needs of your users.
Visibility control
--------------------------------------------------------------------------
Meduims
Scorecard report and reminders
Automatically send Slack reminders or reports relating to scorecards or initiatives. This reminds developers of standards that should be met, and helps managers stay on top of changes or initiatives.
Reminders and reports
Sync Jira tasks with scorecards
Often, developers need to perform different code and configuration changes to reach desired standards as defined in scorecards or initiatives.
You can now automatically open Jira tasks in case standards aren’t met, and also close them upon resolution.
Sync jira with scorecards
New developer portal guides
To help you quickly get up and running with Port, we have created step-by-step guides for common use cases to implement in your developer portal.
Here are new guides from the last month:
  1. Visualize your services' k8s runtime
  2. Let developers enrich services using Gitops
To view all guides, see the guides docs page or go to Port’s guides hub by going to the “Builder” page → clicking the “Guides” button at the top right of the page.
--------------------------------------------------------------------------
Smalls
Control the payload of a self-service action
When using the Port agent for self-service actions, you can now alter the requests sent to your third-party application by providing a payload mapping config file when deploying the Port-agent container.
This will allow you to curate the payload sent to 3rd party applications according to their specific requirements.
Set the initial filters in a catalog page
You can now change the initial catalog page filters to determine the initial data displayed on a catalog page. This is useful for creating more focused views by default, without filtering the table after it loads.
To change the initial filters, click on the page menu button → click on “Edit page”.
Initial filters
Here are October's release notes. If there is an overarching theme, it is that of personalization and visualization. With new table summaries, we allow you to create valuable home pages, dashboards, and catalog views. With FinOps integrations, we provide you with the data to make those views even more powerful.
Biggest
Create detailed dashboards with custom tables 🖼️
With the new table widget, you can display any catalog table in your dashboards by defining custom selections. For instance, a table widget can show all open pull requests or deployments from the last 24 hours. This provides a richer experience to developers and managers.
image
Visualize aggregated data with table summaries 📊
Using Table summaries you can add better data visualization to dashboards, catalog pages and developer/manager home pages.
Column summary - the bottom row of each table displays a summary of all values for each table column.
Group summary - when applying a "group by" to a table, each group will have summaries for that group for each table column.
This capability offers a quick and easy way to consume data, such as:
  1. Aggregated data views that answer questions like "How many Node services are in my organization/team?"
  2. High-level views for managers, team leaders, and developers, such as scorecard levels across services by team/domain, percentage of scorecard rules passed by team/domain, and more.
Table summaries are available in catalog pages and table widgets, as well as dashboards. The current version includes summaries for the following columns: Enum, Scorecards, and Scorecard rules. Stay tuned for more column types in the future.
image
Define accurate authorization conditions with dynamic permissions for self-service actions 🔑
You can now set action execution permissions according to your blueprint definitions. When configuring permissions to execute an action, the new capability can query the catalog to create a permission condition based on these queries. This enables scenarios such as:
  1. Allowing a developer to execute the "Deploy" action only if the developer is related to the same domain as the service.
  2. Allowing a user to execute the "Lock/unlock deployments" action only if the user appears in the catalog as the "team leader" of that service.
See how to define dynamic permissions.
Track and optimize costs using kubecost, opencost, and AWS cost reports 💰
We have added several cost management integrations:
  1. Kubecost and opencost - tools that allow measuring and allocating costs for Kubernetes and other cloud resources.
  2. AWS cost report - contains your resources bill details.
With these new integrations, you can easily bring cost data and incorporate it into your catalog by displaying it in different views and dashboards, enabling developers, teams, and managers to stay on top of costs in the organization at any level (service, team, domain, and more).
Refer to our docs to read more about the kubecost, opencost, and AWS cost integrations.
Personal tokens & access control 👤
Any user can now generate an access token with their authenticated permissions, enabling anyone to have access control at the API usage level.
To generate a personal token, click on the menu button at the right side of the top navigation menu and click on “Credentials”.
image
--------------------------------------------------------------------
Mediums
Additional integrations
We have added more integrations that are powered by Ocean 🌊
  1. FireHydrant - incident management (install here, see docs here).
  2. Snyk - tracking code vulnerabilities (install here, see docs here).
  3. Sentry - APM & alerting (install here, see docs here).
  4. Kafka - event processing data (install here, see docs here).
Dynamic filters for widgets
When filtering the data of a widget, you can now reference user data (such as the user's team). This creates personalized user dashboards.
For example, create a "my open Jira issues" table that will contain only the logged-in user's open issues. This capability is available for all selection-based widgets (pie chart, number chart, and catalog table).
Guides and tutorials
To help you quickly get up and running with Port, we have created step-by-step guides for common use cases to implement in your developer portal.
Each guide covers an end-to-end developer routine, which can be used by your organization when completing it.
To view the guides, see the guides docs page or go to Port’s guides hub by going to the “Builder” page → click on “Guides” button at the top right of the page.
--------------------------------------------------------------------
Smalls
Display scorecard rules as table columns
Scorecard rules can now be displayed as table columns. This lets you create views focusing on improving specific parts of a scorecard and letting users drill down on scorecards easily right from the table.
image
GitLab - monorepo support
The GitLab integration allows exporting of specific folders into catalog entities. This new capability enables visualizing your monorepo services in Port.
GitHub - deployments and environments support
We have added the ability to export deployments and environments into catalog entities.
This month's release notes are all about the developer experience, customizing the developer homepage/dashboard, and helping developers immediately see what's important for them. Additionally, we added tools to make it easier for the portal admins to see which data sources are in use and what they're adding to the portal.
Biggest
Manage integrations and APIs with the “Data Sources” screen 🔌
“Data sources” is a new addition to the "Builder" section. It unifies all integrations and APIs in one place. This allows you to:
  1. Easily understand which data sources are connected to Port and which sources are being ingested into which blueprint.
  2. Easily connect new data sources using our in-product installation guides.
  3. Connect and view multiple sources of the same type. For example, installing the K8s integration on multiple Clusters.
image
Get R&D process insights with Dashboards 📊
You can now create dashboards that will appear as a page in the main catalog side menu (in addition to the dashboard tab on the specific entity page). Each dashboard can contain multiple widgets that display graphs and metrics related to your entire catalog, supporting various use cases such as SDLC, DORA metrics, cost management, system performance, and more ✨
Dashboards and catalog pages can be created using the "New" button in the Catalog.
image
Create personalized experiences with Homepage Customization 🏠
The homepage is now customizable. It supports adding multiple widgets, such as charts, iframes, and markdowns.
Coming soon - create dynamic filters for dashboard widgets. This supports creating a personalized experience on the homepage and any other dashboard.
Home
------------------------------------------
Mediums
Related entities widget - new tab
The “related entities” widget automatically displays a specific entity's upstream and downstream relations. Each relation is displayed as a tab with a table containing all related entities.
The “New tab” button allows you to add multiple relation tabs to add relations that are not automatically displayed by the widget and create different views. For example, Adding two deployment tabs, one for staging and one for production.
Specific entity page - reorder tabs
The specific entity page is now more customizable! Change the order of the entity page tabs to show the most important content to your users first.
Reorder tabs
Self-service actions - synced webhook invocation method
When defining a “webhook” invocation method for a self-service action, we have added the ability to define a “sync” webhook type. When this type is configured, Port will automatically determine the action status according to the HTTP response status code.
This capability is in addition to the already existing “Async” webhook type, in which Port will wait for the action status to be updated via an API call as part of the action’s logic.
Read more about the webhook invocation method.
image
------------------------------------------
Smalls
GitLab integration - repository search
We have added support for mapping GitLab file content into Port using GitLab Advanced Search API. Combined with scorecards, you can define organizational standards across your repositories.
GitHub integration - GitHub teams & dependebot alerts support
We have added support for mapping GitHub teams & GitHub dependebot alerts into Port, allowing you to visualize:
  1. GitHub teams and their relations to each repository.
  2. Alerts detected by GitHub’s dependebot for your repositories, including the alert’s description and status.
See how to map GitHub teams and dependebot alerts into Port.
Swagger UI - YAML spec support
When creating a “Swagger UI” blueprint property, you can now ingest the API spec as YAML in addition to the URL and object formats.
Read more about the “Swagger UI” property.
image
August is summer and summer is vacation time. Don’t ask us how we accomplished everything in these release notes… here they are:
Biggest
Ocean (OSS integration framework) 🚢
1. At last, we launched our open-source extensibility framework project -
Ocean! 🌊
2. Ocean lets you easily extend Port’s capabilities by creating new integrations using a robust OSS framework that takes care of all the repetitive work, so you can focus on adding new capabilities to your developer portal. It works well for third party tools as well as anything in-house you’d like to integrate into the portal.
3. You can now expect to see many new integrations coming from Port. With the community, even more 👥
4. We’re really curious to see what the Port community will do with Ocean. You can learn more here
.
5. In the near future we plan to add capabilities to Ocean, dealing with the backend side of developer self-service actions.
Azure integration
1. Our new Azure integration allows you to collect resource data from Azure and add it to the developer portal.
2. Since the integration is powered by Ocean it supports smart filters and transformations to make it easier to map Azure resources to the desired Port Entities.
Self-service actions - form inputs now support secrets
1. You can now define a Secret input when building the self-service action form. Values that are entered into the Secret input will be encrypted before being sent and will not be saved in Port. This is a great way to let your users enter secrets as part of the self-service actions (such as passwords, private keys, and tokens) in a secure way.
image
---------------------------------
Mediums
Ocean extensions - it ain’t over yet!
1. In addition to the Azure exporter mentioned above, we added several highly requested integrations:
2. Jira
image
GitLab search in the repository’s files capability
1. By installing our GitLab integration, you can now search in files and perform logical checks on file contents to determine whether a file exists in the repository or if files in the repository contain specific keywords.
2. A good example of using this is the ability to check if a repository contains a file and define a scorecard to enforce standards related to it.
Terraform scorecard resource
1. You can now define scorecards as code using our Terraform Provider.
Enum multiple selection
1. There is a new property for both self-service actions & blueprint properties that lets you multi-select through a closed list of enums
2. See how to configure it for blueprints and for self-service actions
image
UI/UX improvements
1. When defining a calculated property, you can now test it in a playground in full page view:
image
image
2. We also improved the flow while configuring custom integrations.
  • We divided the mapping section into steps, that match the flow of the user
  • We added an option to “Load latest event” from the API, which helps configuring webhooks on real data examples
image
iframe widget
1. In addition to the already available Pie chart and Number widgets, you can now use an iframe widget in the dashboard page to specify any external URL and custom component
image
Smalls
Deleting blueprints and all of the corresponding entities
1. You can now delete the blueprint and all of its entities from the UI or API without any limit on the number of entities that will be deleted in the operation, all in a single request. Previously there was a limit of 1000 and it required 2 different calls to do so.
image
It’s August already and although summer is here (and pretty hot ☀️) we’re still working furiously to deliver a better Port. Here’s what we were up to in July:
Biggest
GitLab integration improvements 🔌
Our GitLab integration is better than ever! It now supports GitOps, an easier installation, updating the configuration using Port’s UI and more.
We built it from the ground up using
Port Ocean
🌊 An open-source framework that effectively lets anyone create an exporter to bring the data they need into Port. We haven’t announced it yet, but it’s already in use. 
If you already configured the GitLab using our previous template, you can quickly delete the webhook mappings using the following API call and upgrade to the new integration:
curl -X 'DELETE' \ 'https://api.getport.io/v1/webhooks/gitlabIntegration' \ -H 'accept: */*' \ -H 'Authorization: Bearer <TOKEN>'
Global search 🔍
The new global search allows you to quickly search for any object in your catalog from anywhere in Port! The first version includes:
  1. Searching catalog entities - easily search for a microservice, environment, or any entity without navigating through the catalog ✨
  2. Searching Tech Docs - Port will index all your markdown documents ingested into Port for an easy search experience, turning your developer portal into an engineering documentation hub 📑
The next versions of the global search will include additional search options such as pages, actions, blueprints, and more. Stay tuned!
image
  1. Terraform SDK update
Terraform makes it easy to integrate Port with your existing IaC definitions. Every resource provisioned by Terraform can also be reported to the software catalog using the same 
.tf
 definition file.
Port Terraform Provider v1.0 is a new framework that provides significantly Improved data access, advanced troubleshooting capabilities, fewer type assertions, and more!
Due to its scale, this new version introduces some breaking changes. Before upgrading, please refer to the full changelog and migration guide.
---------------------------------
Mediums
Define a GitOps-based catalog using Port CRDs
You can now use GitOps, Port's K8s exporter, and Port's Entity CRDs to export custom entities into Port. This will enable scenarios such as:
  1. Use your K8s clusters as the source-of-truth for your microservices, packages, libraries and other software catalog assets;
  2. Update Port in a "Push Only" method, where no elevated permissions are required for Port to interact with your infrastructure;
  3. Allow developers to keep the catalog up-to-date, by making updates to Kubernetes manifest files in their Git repositories;
  4. Create a standardized way to document software catalog assets in your organization;
  5. And more
Manage actions using the self-service hub
Admins can now create, edit, and delete self-service actions using the self-service hub in addition to the “Builder” page.
image
Checklist for the first steps with your developer portal implementation
Do you want to start using Port but don’t know where to start? A simple checklist is now displayed on the “Builder” page, containing all steps needed to get started with Port.
image
Dashboards - hourly, daily, weekly, and monthly averages for the number chart
When defining the "average" aggregation for the number chart, you can now calculate a daily, weekly, or monthly average in addition to the existing total average.
This will enable scenarios such as calculating DORA metrics. For example, the "Average weekly deployment frequency" in the last month.
---------------------------------
Smalls
Export catalog to Terraform HCL format
You can now export your entire catalog data to Terraform HCL format in addition to the already existing JSON and YAML formats. This will let you easily manage your catalog alongside your .tf definition files.
image
Change input order in the self-service action form
1. Admins can now control the order of self-service action inputs using Port’s interface or API, allowing you to tailor the form structure to create an optimal experience when filling out the form.
Self-service form
June is almost over, and here come our product release notes. We’re making great strides with making the product more personalized for developers, with the new homepage as well as better support for developer self-service creation. Data migrations are there since blueprints and data models constantly evolve (as they should) as well as a new addition of an ability to import backstage catalog data.
Biggest
Homepage 🏠
The new homepage is a user-personalized dashboard containing several widgets with useful information for the user at the personal/team/organizational level/s. The first version of the homepage includes the following widgets:
  • My entities - a summary of the entities that belong to the user at the team level or at the user property level (for example, if the user appears in a service's “on-call” property).
  • Recently viewed entities - the last entities that the user viewed. This lets users easily navigate to often-visited entities.
  • Recently used actions - the last actions the user performed. This lets users easily navigate to often-performed actions.
  • Readme widget (optional) - allows admins to add a markdown document on the homepage. This document can contain content and information you would like your users to see, such as guides, news, helpful links, etc.
We plan to add more widgets and make the home page flexible, so you can personalize it to meet the needs of users ⚡️🚀
image
Visual editor for developer self-service actions ⚡️
Creating self-service actions is now easier than ever!
You can now configure actions using an intuitive and easy-to-use visual interface (instead of the JSON editor). This new editor includes:
  • Visual creation of the user form inputs.
  • Installation guides and dynamic code examples to help you quickly get started with the action logic implementation.
  • No-code RBAC settings for each action enable you to easily determine who can perform each action.
You can create/edit actions by going to the “Builder” page → expanding a blueprint → clicking on the “Actions” tab.
Actions
Data migrations 🔁
Port’s “bring your own data model” approach lets you build a developer portal containing the assets relevant to your organization. This is done through Port’s blueprint capability. We understand that developer portals constantly evolve and that the data model (and blueprints) needs to be regularly adjusted to support new use cases inside the organization.
For that scenario, we added “Data migration” - a way for admins to define data transformation on the catalog to perform data model changes. For example, changing a “String” property to a “Number” property can now be updated on all entities of a specific blueprint in one click.
To use data migrations, go to the “Builder” → expand a blueprint → click on the blueprint’s three dots menu button → click on the “Migrate data” button.
image
---------------------------------
Mediums
Import your Backstage catalog in minutes
Do you want to use Port and have some data in a Backstage instance? Now you can transfer your data model and entities from Backstage into Port with a few simple steps.
Self-service actions - trigger GitLab Pipelines
We have added the ability to trigger a GitLab Pipeline when executing a self-service action.
Installing the AWS integration with terraform
Installing Port’s AWS integration has just become a lot easier.
You can now use pre-made terraform code to create blueprints, install the integration on your AWS account, and ingest data into Port with one terraform apply!
---------------------------------
Smalls
Export catalog data
The new “Export Data” button in the top bar menu allows you to export catalog entities to JSON/GitOps (.YAML) formats.
image
Audit log - displaying the request body for failed audit logs
You can now expand the audit record and see its request body when viewing failed audit logs. This is super useful when debugging data ingestion issues.
image
Load More