feat(kubernetes): add core group with PVC + LoadBalancer Service [FIX-331] (#78)

Author: liamcervante

pkg/tree/kubernetes/apps/stateful_set.go

@@ -1,6 +1,7 @@
 package apps
 
 import (
+	"github.com/infracost/go-proto/pkg/tree/kubernetes/core"
 	"github.com/infracost/go-proto/pkg/tree/kubernetes/workload"
 	"github.com/infracost/go-proto/pkg/tree/value"
 )
@@ -10,4 +11,11 @@ import (
 type StatefulSet struct {
 	workload.Workload `tree:"-"`
 	Replicas          value.Int `tree:"replicas"`
+
+	// VolumeClaimTemplates are spec.volumeClaimTemplates. A StatefulSet
+	// provisions one persistent volume per template per replica, so the storage
+	// cost is (sum of these) x Replicas — which is why they live on the
+	// StatefulSet rather than as standalone PersistentVolumeClaims in the core
+	// group.
+	VolumeClaimTemplates []core.StorageRequest `tree:"volume_claim_template"`
 }

pkg/tree/kubernetes/core/core.go

@@ -0,0 +1,17 @@
+// Package core models the Kubernetes core API group (the "" group, apiVersion
+// v1) as a service in the tree. Unlike the apps and batch groups — whose members
+// are all workloads sharing the workload type — the core group holds the two
+// cost-relevant non-workload kinds: PersistentVolumeClaim (a request for a
+// dynamically provisioned cloud disk) and Service (only type: LoadBalancer,
+// which provisions a cloud load balancer). Both are cloud spend created outside
+// the cluster's node pools, so nothing in the node-pool IaC accounts for them.
+//
+// Each slice is tagged with the kind, which becomes the resource Type on the
+// wire — mirroring the apps and batch groups.
+package core
+
+// Core is the core/v1 API group.
+type Core struct {
+	PersistentVolumeClaims []PersistentVolumeClaim `tree:"persistentvolumeclaim"`
+	Services               []Service               `tree:"service"`
+}

pkg/tree/kubernetes/core/persistent_volume_claim.go

@@ -0,0 +1,49 @@
+package core
+
+import (
+	"github.com/infracost/go-proto/pkg/tree/resource"
+	"github.com/infracost/go-proto/pkg/tree/value"
+)
+
+// StorageRequest is the cost-relevant sizing of a persistent volume: the
+// requested capacity and the storage class that selects the backing disk SKU.
+// The storage class is the price driver (e.g. "gp3" vs "io2" on AWS,
+// "premium-rwo" vs "standard-rwo" on GKE differ several-fold per GB), and the
+// request is the exact provisioned size — so this pair is enough to price the
+// volume without cluster or API access.
+//
+// It is shared by a standalone PersistentVolumeClaim (embedded, so its fields
+// sit at the claim's top level) and by the volumeClaimTemplates of a StatefulSet
+// (see the apps package), where one such volume is provisioned per replica.
+type StorageRequest struct {
+	// StorageClassName is spec.storageClassName. Empty means the cluster's
+	// default StorageClass — the parser leaves it empty rather than guessing, so
+	// the downstream pricer can fall back to a documented default.
+	StorageClassName value.String `tree:"storage_class_name"`
+
+	// RequestBytes is spec.resources.requests.storage reduced to bytes — the
+	// canonical base unit a Kubernetes quantity reduces to ("10Gi" ->
+	// 10737418240), exact regardless of the suffix the author used. The
+	// downstream pricer converts to GB as part of its rate.
+	RequestBytes value.Int `tree:"request_bytes"`
+}
+
+// PersistentVolumeClaim is a core/v1 PersistentVolumeClaim: a request that a
+// dynamic provisioner satisfies with a real cloud volume (EBS / Persistent Disk
+// / Azure disk). That volume is billed independently of the nodes, so — unlike
+// per-workload compute — pricing it does not double-count anything the node-pool
+// IaC already covers.
+//
+// The kind, address ([namespace, kind, name]) and source range live on the
+// embedded resource.Resource; the claim's Kubernetes labels are stored as the
+// base resource's Tags (reusing the tag machinery, as workloads do).
+type PersistentVolumeClaim struct {
+	resource.Resource `tree:"-"`
+	StorageRequest    `tree:"-"`
+
+	// Annotations are the claim's Kubernetes annotations, surfaced verbatim so
+	// downstream consumers can sniff cloud-provider signals (IRSA role ARNs,
+	// GKE/Azure workload-identity annotations, etc.) — matching how the workload
+	// type carries them.
+	Annotations []resource.Tag `tree:"annotations"`
+}

pkg/tree/kubernetes/core/service.go

@@ -0,0 +1,40 @@
+package core
+
+import (
+	"github.com/infracost/go-proto/pkg/tree/resource"
+	"github.com/infracost/go-proto/pkg/tree/value"
+)
+
+// Service is a core/v1 Service. Only type: LoadBalancer carries cost — it makes
+// the cloud-controller-manager provision a real cloud load balancer (ALB/NLB,
+// GCP forwarding rule, Azure LB) — so the parser only surfaces those; the Type
+// is retained verbatim so downstream consumers can confirm it. ClusterIP /
+// NodePort / ExternalName Services are free and are not represented here.
+//
+// The kind, address ([namespace, kind, name]) and source range live on the
+// embedded resource.Resource; the Service's Kubernetes labels are stored as the
+// base resource's Tags.
+type Service struct {
+	resource.Resource `tree:"-"`
+
+	// Type is spec.type — expected to be "LoadBalancer" for every Service the
+	// parser surfaces.
+	Type value.String `tree:"type"`
+
+	// Annotations are the Service's Kubernetes annotations, surfaced verbatim.
+	// For load balancers these select the flavour that drives the price — e.g.
+	// service.beta.kubernetes.io/aws-load-balancer-type (nlb vs the default
+	// classic ELB) — as well as the cloud-provider signals the workload type
+	// also carries.
+	Annotations []resource.Tag `tree:"annotations"`
+
+	// Ports are the service ports (spec.ports), each becoming a listener on the
+	// provisioned load balancer.
+	Ports []ServicePort `tree:"ports"`
+}
+
+// ServicePort is a single entry of a Service's spec.ports.
+type ServicePort struct {
+	Port     value.Int    `tree:"port"`
+	Protocol value.String `tree:"protocol"`
+}

pkg/tree/kubernetes/kubernetes.go

@@ -1,15 +1,20 @@
 // Package kubernetes is the Kubernetes provider in the resource tree. It groups
-// workloads by their Kubernetes API group (the service layer): apps/v1 and
-// batch/v1. Workloads themselves share a single type — see the workload package.
+// resources by their Kubernetes API group (the service layer): apps/v1,
+// batch/v1 and the core (v1) group. The apps and batch groups hold workloads,
+// which share a single type — see the workload package. The core group holds
+// the cost-relevant non-workload kinds (PersistentVolumeClaim, LoadBalancer
+// Service) — see the core package.
 package kubernetes
 
 import (
 	"github.com/infracost/go-proto/pkg/tree/kubernetes/apps"
 	"github.com/infracost/go-proto/pkg/tree/kubernetes/batch"
+	"github.com/infracost/go-proto/pkg/tree/kubernetes/core"
 )
 
-// Kubernetes is the provider node for Kubernetes workloads.
+// Kubernetes is the provider node for Kubernetes resources.
 type Kubernetes struct {
 	Apps  apps.Apps   `tree:"apps"`
 	Batch batch.Batch `tree:"batch"`
+	Core  core.Core   `tree:"core"`
 }

pkg/tree/kubernetes_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/infracost/go-proto/pkg/tree/kubernetes"
 	"github.com/infracost/go-proto/pkg/tree/kubernetes/apps"
 	"github.com/infracost/go-proto/pkg/tree/kubernetes/batch"
+	"github.com/infracost/go-proto/pkg/tree/kubernetes/core"
 	"github.com/infracost/go-proto/pkg/tree/kubernetes/workload"
 	"github.com/infracost/go-proto/pkg/tree/resource"
 	"github.com/infracost/go-proto/pkg/tree/value"
@@ -57,6 +58,18 @@ func TestKubernetesRoundTrip(t *testing.T) {
 						},
 					},
 				},
+				StatefulSets: []apps.StatefulSet{
+					{
+						Workload: workload.Workload{Resource: resource.Resource{ID: "db"}},
+						Replicas: value.New[int64](3, 0, "", nil),
+						VolumeClaimTemplates: []core.StorageRequest{
+							{
+								StorageClassName: value.New("gp3", 0, "", nil),
+								RequestBytes:     value.New[int64](10737418240, 0, "", nil),
+							},
+						},
+					},
+				},
 			},
 			Batch: batch.Batch{
 				CronJobs: []batch.CronJob{
@@ -70,12 +83,52 @@ func TestKubernetesRoundTrip(t *testing.T) {
 					},
 				},
 			},
+			Core: core.Core{
+				PersistentVolumeClaims: []core.PersistentVolumeClaim{
+					{
+						Resource: resource.Resource{
+							ID: "data",
+							Tags: resource.Tags{
+								{Key: value.New("app", 0, "", nil), Value: value.New("api", 0, "", nil)},
+							},
+						},
+						StorageRequest: core.StorageRequest{
+							StorageClassName: value.New("io2", 0, "", nil),
+							RequestBytes:     value.New[int64](21474836480, 0, "", nil),
+						},
+						Annotations: []resource.Tag{
+							{
+								Key:   value.New("volume.beta.kubernetes.io/storage-provisioner", 0, "", nil),
+								Value: value.New("ebs.csi.aws.com", 0, "", nil),
+							},
+						},
+					},
+				},
+				Services: []core.Service{
+					{
+						Resource: resource.Resource{ID: "api-lb"},
+						Type:     value.New("LoadBalancer", 0, "", nil),
+						Annotations: []resource.Tag{
+							{
+								Key:   value.New("service.beta.kubernetes.io/aws-load-balancer-type", 0, "", nil),
+								Value: value.New("nlb", 0, "", nil),
+							},
+						},
+						Ports: []core.ServicePort{
+							{Port: value.New[int64](443, 0, "", nil), Protocol: value.New("TCP", 0, "", nil)},
+						},
+					},
+				},
+			},
 		},
 	}
 
 	origDep := original.Kubernetes.Apps.Deployments[0]
 	origDaemon := original.Kubernetes.Apps.DaemonSets[0]
+	origSts := original.Kubernetes.Apps.StatefulSets[0]
 	origCron := original.Kubernetes.Batch.CronJobs[0]
+	origPVC := original.Kubernetes.Core.PersistentVolumeClaims[0]
+	origSvc := original.Kubernetes.Core.Services[0]
 
 	proto, err := original.ToProto()
 	require.NoError(t, err)
@@ -87,6 +140,12 @@ func TestKubernetesRoundTrip(t *testing.T) {
 	require.NotNil(t, depAttrs["containers"], "embedded base fields must be flattened")
 	require.NotNil(t, depAttrs["annotations"], "embedded base fields must be flattened")
 
+	// The PersistentVolumeClaim embeds StorageRequest, so its storage fields are
+	// flattened to the claim's top level rather than nested under an embed key.
+	pvcAttrs := proto.Providers["kubernetes"].Services["core"].Resources[0].Attributes.Entries
+	assert.Equal(t, origPVC.StorageClassName.Value(), pvcAttrs["storage_class_name"].GetStringValue())
+	assert.Equal(t, origPVC.RequestBytes.Value(), pvcAttrs["request_bytes"].GetIntValue())
+
 	result, err := FromProto(proto)
 	require.NoError(t, err)
 
@@ -111,6 +170,37 @@ func TestKubernetesRoundTrip(t *testing.T) {
 	require.Len(t, daemon.Containers, len(origDaemon.Containers))
 	assert.Equal(t, origDaemon.Containers[0].Name.Value(), daemon.Containers[0].Name.Value())
 
+	// StatefulSet volumeClaimTemplates: a slice of nested StorageRequest structs.
+	require.Len(t, result.Kubernetes.Apps.StatefulSets, 1)
+	sts := result.Kubernetes.Apps.StatefulSets[0]
+	assert.Equal(t, origSts.ID, sts.ID)
+	assert.Equal(t, origSts.Replicas.Value(), sts.Replicas.Value())
+	require.Len(t, sts.VolumeClaimTemplates, len(origSts.VolumeClaimTemplates))
+	assert.Equal(t, origSts.VolumeClaimTemplates[0].StorageClassName.Value(), sts.VolumeClaimTemplates[0].StorageClassName.Value())
+	assert.Equal(t, origSts.VolumeClaimTemplates[0].RequestBytes.Value(), sts.VolumeClaimTemplates[0].RequestBytes.Value())
+
+	// core group: PersistentVolumeClaim (embedded StorageRequest) and Service.
+	require.Len(t, result.Kubernetes.Core.PersistentVolumeClaims, 1)
+	pvc := result.Kubernetes.Core.PersistentVolumeClaims[0]
+	assert.Equal(t, origPVC.ID, pvc.ID)
+	assert.Equal(t, origPVC.StorageClassName.Value(), pvc.StorageClassName.Value())
+	assert.Equal(t, origPVC.RequestBytes.Value(), pvc.RequestBytes.Value())
+	require.Len(t, pvc.Tags, len(origPVC.Tags))
+	assert.Equal(t, origPVC.Tags[0].Key.Value(), pvc.Tags[0].Key.Value())
+	require.Len(t, pvc.Annotations, len(origPVC.Annotations))
+	assert.Equal(t, origPVC.Annotations[0].Key.Value(), pvc.Annotations[0].Key.Value())
+	assert.Equal(t, origPVC.Annotations[0].Value.Value(), pvc.Annotations[0].Value.Value())
+
+	require.Len(t, result.Kubernetes.Core.Services, 1)
+	svc := result.Kubernetes.Core.Services[0]
+	assert.Equal(t, origSvc.ID, svc.ID)
+	assert.Equal(t, origSvc.Type.Value(), svc.Type.Value())
+	require.Len(t, svc.Annotations, len(origSvc.Annotations))
+	assert.Equal(t, origSvc.Annotations[0].Key.Value(), svc.Annotations[0].Key.Value())
+	require.Len(t, svc.Ports, len(origSvc.Ports))
+	assert.Equal(t, origSvc.Ports[0].Port.Value(), svc.Ports[0].Port.Value())
+	assert.Equal(t, origSvc.Ports[0].Protocol.Value(), svc.Ports[0].Protocol.Value())
+
 	// Multi-level embedding: CronJob -> Job -> Workload all flatten together.
 	require.Len(t, result.Kubernetes.Batch.CronJobs, 1)
 	cj := result.Kubernetes.Batch.CronJobs[0]