Blog
/
/
Using an internal developer portal for superior FinOps visibility
Use Case

Using an internal developer portal for superior FinOps visibility

Apr 2, 2024
Aidan O'Connor
Use Case

Port enables you to contextualize FinOps by pulling in and combining data from multiple sources

Introduction

I joined Port as a Solutions Engineer in early January. In my day to day, I’m meeting with engineering organizations seeking to redefine developer experience by implementing an internal developer portal. The portal provides everything developers need in one centralized place. 

We always start the process by scoping several high-value use cases that comprise a minimum viable portal, which helps them to deliver quick value that solves pain in their developer’s daily lives, thus ensuring a high adoption rate. While creating these user stories, I was surprised at the amount of prospects and customers that wanted to contextualize their cloud costs using a portal.

Problem statement - cloud costs 

Developers at these organizations are tasked with optimizing the cost of their applications, but are given little context to do so. These organizations invest in cloud cost tracking and optimization tools such as KubeCost, but:

  • Developers are unable to comprehend the many resources that comprise a single service, so they have no insight into how much a service costs, and can therefore do little to optimize a service’s cloud costs.
  • Tech leads and product managers are unable to see how much a namespace costs, and they have no way of doing so with cost reports, so they are hindered in planning their roadmap with cloud resources in mind.
  • Engineering team leaders are unable to determine which team owns which resource, or which resources their team’s services use, leaving them unable to effectively request and maintain a cloud budget.
  • FinOps teams are unaware which resources are aligned to which service, so they are unsure which resource cost optimizations can be implemented without disrupting service functionality.

While this was not among the typical portal use cases I had researched before joining Port, it made sense: one of the advantages of using Port is centralizing development routines and tools, and cloud cost data is no exception. Because Port integrates with the platform tools, it can pull in and combine data from these tools, adding valuable depth. This means teams handling FinOps get a clearer picture by seeing their cloud bills with the added context of development activities. At the same time, development teams can benefit from properly contextualized cloud cost data to tweak their resource configurations without sacrificing functionality.

How Port can help

Portals are made up of five main pillars: a software catalog, a scorecard layer, a developer self-service actions layer, a visualization layer and a workflow automation layer.
Given the above context, Port is able to help relieve the pain described in the following ways:

  • The Software catalog can include cost data, which can be aligned to teams, services, and domains, giving developers, managers, and FinOps teams a common operating picture to optimize the cost of a service, not just the resources that serve it.

  • Scorecards allow leadership to monitor compliance with standards set by FinOps without depending on data calls or running scripts on otherwise unintelligible cost reports.

  • Self-service actions bring powerful cost predictions directly to the developer while they create development environments.

  • Dashboards enable engineering leaders and FinOps teams to visualize the data that matters most, such as cost per service, domain, and team.

  • Automations: Port can, for example, auto-terminate a developer environment after it reaches a predefined TTL. 

Technical guide: ingesting and relating resources and costs

With very little experience using Port, I decided to take on the challenge to ingest cloud cost data into Port, relate it to the correct services, and relate those services to teams. Here how you can follow what I did:

Ingesting resources and costs

Begin by ingesting your cloud resources to Port by following the instructions provided in the installation instructions here. This will allow you to view your cloud resources in a centralized catalog using blueprints, which are the most basic building blocks in Port, allowing you to represent assets in your organization. The blueprints that are created by following these steps depend on user preferences, but are generally major resource types in your cloud provider of choice.

Next, ingest your cloud costs using the tool of your choice, such as Kubecost, which provides granular insights into resource utilization, empowering teams to optimize their Kubernetes spending effectively. Kubecost’s comprehensive interface and analytics have made it a go-to solution for businesses seeking to control costs without compromising performance. Kubecost is built on OpenCost, an open-source Kubernetes cost visibility solution that is managed by and part of the CNCF.

Relating resources and costs

Finally, maximize the advantage of using Port by relating your resources and their costs. Relations define connections between blueprints, consequently connecting the entities based on these blueprints. This provides logical context to the software catalog.

Go to your Builder page and relate your costs to your resources by expanding your cost blueprint and clicking ‘New relation’. Enter the required parameters (provide a title, select the intended cloud resource from the ‘Related to’ dropdown, select ‘one entity’ (since a single cost line item is associated with a single resource), and select whether or not it should be a required relation.

If you have already ingested your services from your git provider, relate these resources to the services that run within them by following the same process described above, only this time the service should be tied to the cluster in which it runs.

This process lets you see:

  • Costs tied to resources that are associated with the services they host.
  • Additional business domain information that enables you to determine which services cost more than they contribute to the domain they serve.

This crucial contextual information enables you to:

  • Easily identify where to adjust spending for better financial efficiency.
  • Aggregate costs per domain, ensuring that non-revenue generating domains do not exceed budgets (crucial for monitoring costs of goods sold).

Creating a FinOps dashboard

Now that you have resources and resource costs ingested and related in Port, make a view that is useful for you, such as a FinOps Dashboard, where FinOps and Engineering teams can collaborate on cloud resource costs effectively. Let’s take a look at these example views offered on our public demo site.

Ensure environment costs are appropriately balanced

FinOps teams seeking to lower their cloud costs can both optimize production environment resources and ensure development environment costs are not excessive. A view like the one below brings all resource costs across all environments into one view, allowing FinOps teams to monitor the effect of their cost optimization initiatives.

Drill down into individual resource costs by environment and team

If the number charts in the dashboard view above reveal alarming information about environment costs, FinOps teams can use the table views below in the same dashboard to drill down into resource costs, grouping by environment, team, or any other property in the table. Identify an anomalous environment cost using the view above, then find the offending resource (or resources) in the table below.

Conclusion

FinOps tools provide visibility into cloud spending, presenting the information available from the cloud provider, which doesn’t always tell the full picture.

By using Port to contextualize cloud resource costs:

  • Developers can build their applications that comply with FinOps standards – no more building applications at all costs
  • FinOps teams can embrace the service context not included in their cost reports and effectively collaborate with developers on cost optimization efforts – no more myopic focus on cost reduction

Data from FinOps tools must be enriched by data from development tools, aligning cost to resource; resource to service; and service to team and domain. With a common understanding, finance can drive effective investment initiatives and development teams can effectively deploy their applications with an eye towards cost. By using a portal, developers, engineering leaders, and FinOps teams can maximize their investment in cloud cost tracking tools and optimize their cloud costs without sacrificing service functionality.

{{cta}}

Book a demo right now to check out Port's developer portal yourself

Book a demo
{{jenkins}}

It's a Trap - Jenkins as Self service UI

Read more
{{gitops}}

How do GitOps affect developer experience?

Read more
{{ebook}}

It's a Trap - Jenkins as Self service UI. Click her to download the eBook

Download eBook
{{cyberark}}

Learning from CyberArk - building an internal developer platform in-house

Read more
{{dropdown}}

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

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

Check live demo

No email required

Contact sales for a technical product walkthrough

Let’s start

Open a free Port account. No credit card required

Let’s start

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

Let’s start

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

(no email required)

Let’s start

Contact sales for a technical product walkthrough

Let’s start

Open a free Port account. No credit card required

Let’s start

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

Let’s start

Let us walk you through the platform and catalog the assets of your choice.

I’m ready, let’s start