Port x Komodor: Improving DevEx for Kubernetes Together

With our new Komodor integration, Port can now help you improve visibility of your Kubernetes clusters in your internal developer portal.

May 27, 2025

Ready to start?

Port x Komodor: Improving DevEx for Kubernetes Together

We’re pleased to announce a new way to integrate Kubernetes with Port, built by the team at Komodor using the Port Ocean open source extensibility framework. Kubernetes and containers revolutionized how apps are built and delivered, and yet, the intricate complexities of Kubernetes generally lead many organizations to want to abstract away any details related to the deployments. But if you’re truly following DevOps practices and something breaks, developers need to know what broke and how to fix it. 

This is the beauty of the Port x Komodor integration: Komodor simplifies Kubernetes management at scale, so operators and SREs can ensure all clusters are healthy and meet company standards. Port, meanwhile, provides a central source for developers to understand their apps from development to production. 

Combining the two enables developers and operators to be on the same page to know if apps are deployed correctly and if they’re healthy, and quickly fix issues when they arise, without the need to know Kubernetes inside and out.

The challenge of bringing Kubernetes details to internal developer portals

Aside from wanting to abstract away the complexities of Kubernetes, another big challenge is figuring out how to relate Kubernetes resources to development assets. It’s not terribly difficult to get Kubernetes objects into most internal developer portals (IDPs) — they’re expected to have rich data about development projects and assets. But connecting the development assets to live Kubernetes objects requires understanding how your repos and pipelines relate to nodes, pods, namespaces, and clusters.

In most IDPs, you have to rethink your Kubernetes deployment strategies to accomplish this, and include specific and precise metadata tags or annotations in order to make the connections between dev assets and Kubernetes objects. It’s a burdensome task that forces every deployment to be updated and is unforgiving if mistakes are made.

Port handles this differently. In Port, we can easily relate repositories to pipeline runs to deployments to live Kubernetes objects. Port is designed to fit the way your teams work so every team responsible for the delivery of applications has a single source of truth: developers know where their apps are running; operators know who is responsible for the apps running on their clusters.

The challenge of managing Kubernetes workloads for developers: Komodor to the rescue

Let’s say you have an end-to-end view of all your apps in Port, which is great. But what do you do when something breaks? 

Troubleshooting Kubernetes applications isn’t trivial even for seasoned Kubernetes pros, but especially for developers. This is the real power of the Port x Komodor integration!

Komodor + Port: A unified interface for code, services — and operations

Komodor solves that problem by embedding Kubernetes observability and incident response directly into Port’s service views, with no context-switching, nor kubectl. Developers receive much-needed Kubernetes context inside the tools the developers are already using, and guided steps to fix issues when they occur.

The Komodor integration provides a live operational lens into Kubernetes workloads — real-time health, deployment diffs, config changes, and actionable alerts — all tied to the services they own. When something breaks, Komodor provides guided remediation steps, along with AI-powered agent, Klaudia, to troubleshoot Kubernetes from within the same IDP they already use to ship code. Kubernetes goes from opaque infrastructure to a manageable part of the developer workflow.

In the example service below, the engineers for the Authorization service have immediate access to health and reliability issues surfaced by Komodor. They can go straight to Komodor monitoring dashboards, or better yet, click the Investigate button to access guided troubleshooting powered by Komodor’s AI assistant, Klaudia. 

Image description: Kubernetes details provided by Komodor regarding the state of a running service are displayed in the Port internal developer portal with links to dashboards, detailed health information, and the ability to use Klaudia, Komodor's AI agent, for guided troubleshooting

At the same time, platform teams gain fleet-wide and multi-cluster visibility, granular RBAC policies and permissions enforcement, and a scalable Day-2 operations layer through built-in automated incident remediation playbooks — all wired into the portal experience. With Port + Komodor, you’re not just connecting tools — you’re closing the loop between deployment, observability, and remediation, while improving reliability engineering and MTTR all within your IDP.

Image description: In Port, Platform teams, operators, and others have fleet-wide and cluster-wide visibility into all services running in Kubernetes, with relevant Komodor health and reliability details and links to Komodor for deeper details.

Why Komodor + Port is a natural fit

Port gives teams the tools to build IDPs that are usable, governed, and extensible. Komodor brings Kubernetes into that equation — not as another silo, but as a native part of the experience.

Together, we are delivering:

  • Real-time operational insights surfaced inside Port, so application teams, operators and all stakeholders are on the same page
  • Secure, developer-friendly workflows that reduce reliance on DevOps
  • Simplified, automated remediation support through tools like Klaudia, Komodor’s AI-powered assistant
  • Full visibility into cluster health, change history, and service dependencies

With this native integration, Kubernetes becomes a transparent part of the platform, and no longer a mystery or black box. Developers gain autonomy, platform teams gain confidence, and the IDP evolves from a static interface into a living, operational product.

Port + Komodor = better developer experience, built on real operational insight.

{{survey-buttons}}

Get your survey template today

By clicking this button, you agree to our Terms of Use and Privacy Policy
{{survey}}

Download your survey template today

By clicking this button, you agree to our Terms of Use and Privacy Policy
{{roadmap}}

Free Roadmap planner for Platform Engineering teams

  • Set Clear Goals for Your Portal

  • Define Features and Milestones

  • Stay Aligned and Keep Moving Forward

{{rfp}}

Free RFP template for Internal Developer Portal

Creating an RFP for an internal developer portal doesn’t have to be complex. Our template gives you a streamlined path to start strong and ensure you’re covering all the key details.

{{ai_jq}}

Leverage AI to generate optimized JQ commands

test them in real-time, and refine your approach instantly. This powerful tool lets you experiment, troubleshoot, and fine-tune your queries—taking your development workflow to the next level.

{{cta_1}}

Check out Port's pre-populated demo and see what it's all about.

Check live demo

No email required

{{cta_survey}}

Check out the 2025 State of Internal Developer Portals report

See the full report

No email required

{{cta_2}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_3}}

Open a free Port account. No credit card required

Let’s start
{{cta_4}}

Watch Port live coding videos - setting up an internal developer portal & platform

{{cta_5}}

Check out Port's pre-populated demo and see what it's all about.

(no email required)

Let’s start
{{cta_6}}

Contact sales for a technical walkthrough of Port

Let’s start
{{cta_7}}

Open a free Port account. No credit card required

Let’s start
{{cta_8}}

Watch Port live coding videos - setting up an internal developer portal & platform

{{cta-demo}}
{{reading-box-backstage-vs-port}}
{{cta-backstage-docs-button}}

Example JSON block

{
  "foo": "bar"
}

Order Domain

{
  "properties": {},
  "relations": {},
  "title": "Orders",
  "identifier": "Orders"
}

Cart System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Cart",
  "title": "Cart"
}

Products System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Products",
  "title": "Products"
}

Cart Resource

{
  "properties": {
    "type": "postgress"
  },
  "relations": {},
  "icon": "GPU",
  "title": "Cart SQL database",
  "identifier": "cart-sql-sb"
}

Cart API

{
 "identifier": "CartAPI",
 "title": "Cart API",
 "blueprint": "API",
 "properties": {
   "type": "Open API"
 },
 "relations": {
   "provider": "CartService"
 },
 "icon": "Link"
}

Core Kafka Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Kafka Library",
  "identifier": "CoreKafkaLibrary"
}

Core Payment Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Payment Library",
  "identifier": "CorePaymentLibrary"
}

Cart Service JSON

{
 "identifier": "CartService",
 "title": "Cart Service",
 "blueprint": "Component",
 "properties": {
   "type": "service"
 },
 "relations": {
   "system": "Cart",
   "resources": [
     "cart-sql-sb"
   ],
   "consumesApi": [],
   "components": [
     "CorePaymentLibrary",
     "CoreKafkaLibrary"
   ]
 },
 "icon": "Cloud"
}

Products Service JSON

{
  "identifier": "ProductsService",
  "title": "Products Service",
  "blueprint": "Component",
  "properties": {
    "type": "service"
  },
  "relations": {
    "system": "Products",
    "consumesApi": [
      "CartAPI"
    ],
    "components": []
  }
}

Component Blueprint

{
 "identifier": "Component",
 "title": "Component",
 "icon": "Cloud",
 "schema": {
   "properties": {
     "type": {
       "enum": [
         "service",
         "library"
       ],
       "icon": "Docs",
       "type": "string",
       "enumColors": {
         "service": "blue",
         "library": "green"
       }
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "system": {
     "target": "System",
     "required": false,
     "many": false
   },
   "resources": {
     "target": "Resource",
     "required": false,
     "many": true
   },
   "consumesApi": {
     "target": "API",
     "required": false,
     "many": true
   },
   "components": {
     "target": "Component",
     "required": false,
     "many": true
   },
   "providesApi": {
     "target": "API",
     "required": false,
     "many": false
   }
 }
}

Resource Blueprint

{
 “identifier”: “Resource”,
 “title”: “Resource”,
 “icon”: “DevopsTool”,
 “schema”: {
   “properties”: {
     “type”: {
       “enum”: [
         “postgress”,
         “kafka-topic”,
         “rabbit-queue”,
         “s3-bucket”
       ],
       “icon”: “Docs”,
       “type”: “string”
     }
   },
   “required”: []
 },
 “mirrorProperties”: {},
 “formulaProperties”: {},
 “calculationProperties”: {},
 “relations”: {}
}

API Blueprint

{
 "identifier": "API",
 "title": "API",
 "icon": "Link",
 "schema": {
   "properties": {
     "type": {
       "type": "string",
       "enum": [
         "Open API",
         "grpc"
       ]
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "provider": {
     "target": "Component",
     "required": true,
     "many": false
   }
 }
}

Domain Blueprint

{
 "identifier": "Domain",
 "title": "Domain",
 "icon": "Server",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {}
}

System Blueprint

{
 "identifier": "System",
 "title": "System",
 "icon": "DevopsTool",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "domain": {
     "target": "Domain",
     "required": true,
     "many": false
   }
 }
}
{{tabel-1}}

Microservices SDLC

  • Scaffold a new microservice

  • Deploy (canary or blue-green)

  • Feature flagging

  • Revert

  • Lock deployments

  • Add Secret

  • Force merge pull request (skip tests on crises)

  • Add environment variable to service

  • Add IaC to the service

  • Upgrade package version

Development environments

  • Spin up a developer environment for 5 days

  • ETL mock data to environment

  • Invite developer to the environment

  • Extend TTL by 3 days

Cloud resources

  • Provision a cloud resource

  • Modify a cloud resource

  • Get permissions to access cloud resource

SRE actions

  • Update pod count

  • Update auto-scaling group

  • Execute incident response runbook automation

Data Engineering

  • Add / Remove / Update Column to table

  • Run Airflow DAG

  • Duplicate table

Backoffice

  • Change customer configuration

  • Update customer software version

  • Upgrade - Downgrade plan tier

  • Create - Delete customer

Machine learning actions

  • Train model

  • Pre-process dataset

  • Deploy

  • A/B testing traffic route

  • Revert

  • Spin up remote Jupyter notebook

{{tabel-2}}

Engineering tools

  • Observability

  • Tasks management

  • CI/CD

  • On-Call management

  • Troubleshooting tools

  • DevSecOps

  • Runbooks

Infrastructure

  • Cloud Resources

  • K8S

  • Containers & Serverless

  • IaC

  • Databases

  • Environments

  • Regions

Software and more

  • Microservices

  • Docker Images

  • Docs

  • APIs

  • 3rd parties

  • Runbooks

  • Cron jobs

Starting with Port is simple, fast and free.

Let’s start