This document provides the steps for installing the Kubecost product from the AWS marketplace. More info pricing of different Kubecost versions.

Step 1: Create an IAM policy

To deploy Kubecost from AWS Marketplace, you need to assign an IAM policy with appropriate IAM permission to a Kubernetes service account before starting the deployment. You can either use AWS managed policy arn:aws:iam::aws:policy/AWSMarketplaceMeteringRegisterUsage or create your own IAM policy. You can learn more with AWS' Create and attach your first customer managed policy tutorial.

Here's an example IAM policy:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "aws-marketplace:RegisterUsage"
                ],
                "Effect": "Allow",
                "Resource": "*"
        }
    ]
}

Step 2: Create an IAM role for service account (IRSA)

We recommend doing this via eksctl. The command below helps to automate these manual steps:

• Create an IAM role with AWS-managed IAM policy.

• Create a K8s service account name awsstore-serviceaccount in your Amazon EKS cluster.

• Set up a trust relationship between the created IAM role with awsstore-serviceaccount.

• Modify awsstore-serviceaccount annotation to associate it with the created IAM role

Remember to replace CLUSTER_NAME with your actual Amazon EKS cluster name.

eksctl create iamserviceaccount \
    --name awsstore-serviceaccount \
    --namespace kubecost \
    --cluster CLUSTER_NAME \
    --attach-policy-arn arn:aws:iam::aws:policy/AWSMarketplaceMeteringRegisterUsage \
    --approve \
    --override-existing-serviceaccounts

More details and how to set up the appropriate trust relationships is available here.

Step 3: Deploy Kubecost with attached IAM role

Define which available version you would like to install using this following command You can check available version titles from the AWS Marketplace product, e.g: prod-1.95.0:

export IMAGETAG=<VERSION-TITLE>

Deploy Kubecost with Helm using the following command:

helm upgrade -i kubecost kubecost/cost-analyzer \
    --namespace kubecost --create-namespace \
    --set prometheus.nodeExporter.enabled=false \
    --set global.grafana.enabled=false \
    --set global.grafana.proxy=false \
    --set awsstore.useAwsStore=true \
    --set awsstore.imageNameAndVersion=709825985650.dkr.ecr.us-east-1.amazonaws.com/stackwatch/awsstore:${IMAGETAG} \
    --set imageVersion=${IMAGETAG} \
    --set kubecostFrontend.image=709825985650.dkr.ecr.us-east-1.amazonaws.com/stackwatch/frontend \
    --set kubecostModel.image=709825985650.dkr.ecr.us-east-1.amazonaws.com/stackwatch/cost-model \
    --set prometheus.server.image.repository=709825985650.dkr.ecr.us-east-1.amazonaws.com/stackwatch/contract/quay.io/prometheus  \
    --set prometheus.server.image.tag=v2.35.0

Run this command to enable port-forwarding and access the Kubecost UI:

kubectl port-forward --namespace kubecost deployment/kubecost-cost-analyzer 9090

You can now start monitoring your Amazon EKS cluster cost with Kubecost by visiting http://localhost:9090.

Installing Kubecost via Helm

Installing Kubecost on an Alibaba cluster is the same as other cloud providers with Helm v3.1+:

helm install kubecost/cost-analyzer -n kubecost -f values.yaml

Your values.yaml files must contain the below parameters:

prometheus:
  server:
    global:
      external_labels:
        cluster_id: aliyun-ali-test-1 # Each cluster should have a unique ID

kubecostProductConfigs:
  clusterName: "aliyun-ali-test-" # used for display in Kubecost UI
  serviceKeySecretName: "alibaba-service-key"

The alibaba-service-key can be created using the following command:

kubectl create secret generic alibaba-service-key -n kubecost –from-file=./example_path

Your path needs a file having Alibaba Cloud secrets. Alibaba secrets can be passed in a JSON file with the file in the format:

{
     "alibaba_access_key_id": “XXX”
     "alibaba_secret_access_key": “XXX"
}

These two can be generated in the Alibaba Cloud portal. Hover over your user account icon, then select AccessKey Management. A new window opens. Select Create AccessKey to generate a unique access token that will be used for all activities related to Kubecost.

Alibaba Cloud integration

Currently, Kubecost does not support complete integration of your Alibaba billing data like for other major cloud providers. Instead, Kubecost will only support public pricing integration, which will provide proper list prices for all cloud-based resources. Features like reconciliation and savings insights are not available for Alibaba. For more information on setting up a public pricing integration, see our Multi-Cloud Integrations doc.

Troubleshooting

Cannot install Kubecost without a default StorageClass

While getting all the available Storage Classes that the Alibaba K8s cluster comes with, there may not be a default storage class. Kubecost installation may fail as the cost-model pod and Prometheus server pod would be in a status pending state.

To fix this issue, make any of the Storage Classes in the Alibaba K8s cluster as Default using the below command:

 kubectl patch storageclass alicloud-disk-available -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}' 

Following this, installation should proceed as normal.

The following requirements are given:

• Rancher with default monitoring

• Use of an existing Prometheus and Grafana (Kubecost will be installed without Prometheus and Grafana)

• Istio with gateway and sidecar for deployments

Activation of Istio

1. Istio is activated by editing the namespace. To do this, execute the command kubectl edit namespace kubecost and insert the label istio-injection: enabled

2. After Istio has been activated, some adjustments must be made to the deployment with kubectl -n kubecost edit deployment kubecost-cost-analyzer to allow communication within the namespace. For example, the healtch-check is completed successfully. When editing the deployment, the two annotations must be added:

annotations:
	traffic.sidecar.istio.io/excludeOutboundIPRanges: "10.43.0.1/32"
	sidecar.istio.io/rewriteAppHTTPProbers: "true"

Authorization polices

An authorization policy governs access restrictions in namespaces and specifies how resources within a namespace are allowed to access it.

ap-ingress: communication with Istio

apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: ap-ingress
  namespace: kubecost
spec:
  rules:
  - from:
    - source:
        principals:
        - cluster.local/ns/istio-system/sa/istio-ingressgateway-service-account

ap-intern: communication with Kubecost

apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: ap-intern
  namespace: kubecost
spec:
  rules:
  - from:
    - source:
        principals:
        - cluster.local/ns/kubecost/sa/kubecost-cost-analyzer

ap-extern: as a port share (9003) for communication from Prometheus (namespace "cattle-monitoring-system") to Kubecost (namespace "kubecost")

apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: ap-extern
  namespace: kubecost
spec:
  rules:
  - to:
    - operation:
        ports:
          - "9003"

Peer Authentication

Peer authentication is used to set how traffic is tunneled to the Istio sidecar. In the example, enforcing TLS is disabled so that Prometheus can grab the metrics from Kubecost (if this action is not performed, it returns at HTTP 503 error).

pa-default.yaml

apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: pa-default
  namespace: kubecost
spec:
  mtls:
    mode: PERMISSIVE

Destination Rule

A destination rule is used to specify how traffic should be handled after routing to a service. In my case, TLS is disabled for connections from Kubecost to Prometheus and Grafana (namespace "cattle-monitoring-system").

dr-prometheus.yaml

apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: dr-prometheus
  namespace: kubecost
spec:
  host: rancher-monitoring-prometheus.cattle-monitoring-system.svc.cluster.local
  trafficPolicy:
    tls:
      mode: DISABLE

dr-grafana.yaml

apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: dr-grafana
  namespace: kubecost
spec:
  host: rancher-monitoring-grafana.cattle-monitoring-system.svc.cluster.local
  trafficPolicy:
    tls:
      mode: DISABLE

Virtual Service

A virtual service is used to direct data traffic specifically to individual services within the service mesh. The virtual service defines how the routing should run. A gateway is required for a virtual service.

vs-kubecost.yaml

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  labels:
    cattle.io/creator: norman
  name: vs-kubecost
  namespace: kubecost
spec:
  gateways:
  - ${gateway}
  hosts:
  - ${host}
  http:
  - match:
    - uri:
        prefix: /kubecost
    rewrite:
      uri: /
    route:
    - destination:
        host: kubecost-cost-analyzer.kubecost.svc.cluster.local
        port:
          number: 9090

After creating the virtual service, Kubecost should be accessible at the URL http(s)://${gateway}/kubecost/.

Installing Kubecost for GKE Autopilot via Helm

Installing Kubecost on a GKE Autopilot cluster is similar to other cloud providers with Helm v3.1+, with a few changes. Autopilot requires the use of Google Managed Prometheus service, which generates additional costs within your Google Cloud account.

helm install kubecost/cost-analyzer -n kubecost -f values.yaml

Your values.yaml files must contain the below parameters. Resources are specified for each section of the Kubecost deployment, and Pod Security Policies are disabled.

kubecostProductConfigs:
  clusterName: "<clusterName>" # used for display in Kubecost UI

kubecostModel:
  promClusterIDLabel: cluster # warning: usage and efficiency will show as zero without this setting enabled
  resources:
    requests:
      cpu: 500m
      memory: 512Mi

kubecostFrontend:
  resources:
    requests:
      cpu: 250m
      memory: 55Mi

global:
  gmp:
    enabled: true # If true, kubecost will be configured to use GMP Prometheus image and query from Google Cloud Managed Service for Prometheus.
    gmpProxy:
      projectId: <GCP Project ID>

serviceAccount:
  annotations:
    iam.gke.io/gcp-service-account: <GCP Service Account with Metrics Writer/Reader Permissions> 

prometheus:
  server:
    image:
      repository: gke.gcr.io/prometheus-engine/prometheus
      tag: v2.41.0-gmp.4-gke.1
    global:
      external_labels:
        cluster_id: <GKE Autopilot Cluster Name>  # cluster_id should be unique for all clusters and the same value as .kubecostProductConfigs.clusterName
  podSecurityPolicy:
    enabled: false
  configmapReload:
    prometheus:
      resources:
        requests:
          cpu: 250m
          memory: 256Mi
  nodeExporter:
    enabled: false
  serviceAccounts:
    nodeExporter:
      create: false
    server:
      annotations: 
        iam.gke.io/gcp-service-account: <GCP Service Account with Metrics Writer/Reader Permissions>

networkCosts:
  enabled: false

podSecurityPolicy:
  enabled: false​

grafana:
  rbac:
    pspEnabled: false
  resources:
    requests:
      cpu: 250m
      memory: 128Mi
  sidecar:
    resources:
      requests:
        cpu: 250m
        memory: 384Mi

Turning on Kubelet/cAdvisor scraping via Google Managed Collector

Open the OperatorConfig on your Autopilot Cluster resource for editing:

kubectl -n gmp-public edit operatorconfig config

Add the following collection section to the resource:

apiVersion: monitoring.googleapis.com/v1
kind: OperatorConfig
metadata:
  namespace: gmp-public
  name: config
collection:
  kubeletScraping:
    interval: 30s

Save the file and close the editor. After a short time, the Kubelet metric endpoints will be scraped and the metrics become available for querying in Managed Service for Prometheus.

Rafay is a SaaS-first Kubernetes Operations Platform (KOP) with enterprise-class scalability, zero-trust security and interoperability for managing applications across public clouds, data centers & edge.

See Rafay documentation to learn more about the platform and how to use it.

This document will walk you through installing Kubecost on a cluster that has been provisioned or imported using the Rafay controller. The steps below describe how to create and use a custom cluster blueprint via the Rafay Web Console. The entire workflow can also be fully automated and embedded into an automation pipeline using the RCTL CLI utility or Rafay REST APIs.

Prerequisites

You have already provisioned or imported one or more Kubernetes clusters using the Rafay controller.

Step 1: Create a repository

Under Integrations:

• Select Repositories and create a new repository named kubecost of type Helm.

• Select Create.

• Enter the endpoint value of https://kubecost.github.io/cost-analyzer/.

• Select Save.

Step 2: Customize values

You'll need to override the default values.yaml file. Create a new file called kubecost-custom-values.yaml with the following content:

# Custom values for Kubecost
reporting:
  valuesReporting: false
# Replace token with the value you get from kubecost.com/install
# after entering your email address
kubecostToken: 'token_string'

Step 3: Create a namespace

• Login to the Rafay Web Console and navigate to your Project as an Org Admin or Infrastructure Admin.

• Under Infrastructure, select Namespaces and create a new namespace called kubecost, and select type Wizard.

• Select Save & Go to Placement.

• Select the cluster(s) that the namespace will be added to. Select Save & Go To Publish.

• Select Publish to publish the namespace to the selected cluster(s).

• Once the namespace has been published, select Exit.

• Under Infrastructure, select Clusters.

• Select the kubectl button on the cluster to open a virtual terminal.

• Verify that the kubecost namespace has been created by running the following command:

$ kubectl get ns kubecost

NAME            STATUS   AGE
kubecost        Active   44m

Step 4: Create an add-on

From the Web Console:

• Select Add-ons and Create a new add-on called kubecost.

• Select Bring your own.

• Select Helm 3 for type.

• Select Pull files from repository.

• Select Helm for the repository type.

• Select kubecost for the namespace.

• Select Select.

• Create a new version of the add-on.

• Select New Version.

• Provide a version name such as v1.

• Select kubecost for the repository.

• Enter cost-analyzer for the chart name.

• Upload the kubecost-custom-values.yaml file that was previously created.

• Select Save Changes.

Step 5: Create a blueprint

Once you've created the Kubecost add-on, use it in assembling a custom cluster blueprint. You can add other add-ons to the same custom blueprint.

• Under Infrastructure, select Blueprints.

• Create a new blueprint and give it a name such as kubecost.

• Select Save.

• Create a new version of the blueprint.

• Select New Version.

• Provide a version name such as v1.

• Under Add-Ons, select the kubecost Add-on and the version that was previously created.

• Select Save Changes.

Step 6: Apply blueprint

You may now apply this custom blueprint to a cluster.

• Select Options for the target cluster in the Web Console.

• Select Update Blueprint and select the kubecost blueprint and version you created previously.

• Select Save and Publish.

This will start the deployment of the add-ons configured in the kubecost blueprint to the targeted cluster. The blueprint sync process can take a few minutes. Once complete, the cluster will display the current cluster blueprint details and whether the sync was successful or not.

Step 7: Verify deployment

You can optionally verify whether the correct resources have been created on the cluster. Select the kubectl button on the cluster to open a virtual terminal.

Then, verify the pods in the kubecost namespace. Run kubectl get pod -n kubecost, and check that the output is similar to the example below.

$ kubectl get pod -n kubecost

NAME                                          READY   STATUS    RESTARTS   AGE
kubecost-cost-analyzer-8544c4bbd4-gx4nl       3/3     Running   0          6m23s
kubecost-grafana-768655466d-vlsmq             3/3     Running   0          6m23s
kubecost-kube-state-metrics-f99c657b5-mh5mt   1/1     Running   0          6m23s
kubecost-prometheus-node-exporter-26fwv       1/1     Running   0          6m23s
kubecost-prometheus-node-exporter-zfkvw       1/1     Running   0          6m23s
kubecost-prometheus-server-5cc6745978-z98f8   2/2     Running   0          6m23s

Step 8: Enable port forwarding

In order to access the Kubecost UI, you'll need to enable access to the frontend application using port-forward. To do this, download and use the Kubeconfig with the KubeCTL CLI (../../accessproxy/kubectl_cli/).

kubectl port-forward --namespace kubecost deployment/kubecost-cost-analyzer 9090

Forwarding from 127.0.0.1:9090 -> 9090
Forwarding from [::1]:9090 -> 9090
Handling connection for 9090

Step 9: View data

You can now access the Kubecost UI by visiting http://localhost:9090 in your browser.

You have now successfully created a custom cluster blueprint with the kubecost add-on and applied to a cluster. Use this blueprint on as many clusters as you require.

You can find Rafay's documentation on Kubecost as well as guides for how to create or import a cluster using the Rafay controller on the Rafay Product Documentation site.

Amazon Elastic Kubernetes Services (Amazon EKS) is a managed container service to run and scale Kubernetes applications in the AWS cloud. In collaboration with Amazon EKS, Kubecost provides optimized bundle for Amazon EKS cluster cost visibility that enables customers to accurately track costs by namespace, cluster, pod or organizational concepts such as team or application. Customers can use their existing AWS support agreements to obtain support. Kubernetes platform administrators and finance leaders can use Kubecost to visualize a breakdown of their Amazon EKS cluster charges, allocate costs, and chargeback organizational units such as application teams.

In this article, you will learn more about how the Amazon EKS architecture interacts with Kubecost. You will also learn to deploy Kubecost on EKS using one of three different methods:

1. Deploy Kubecost on an Amazon EKS cluster using Amazon EKS add-on

2. Deploy Kubecost on an Amazon EKS cluster via Helm

3. Deploy Kubecost on an Amazon EKS Anywhere cluster using Helm

Architecture overview

User experience diagram:

Amazon EKS cost monitoring with Kubecost architecture:

Deploying Kubecost on an Amazon EKS cluster using Amazon EKS add-on

Prerequisites

• Subscribe to Kubecost on AWS Marketplace here.

• Install the following tools: kubectl, AWS CLI, and optionally eksctl.

• You have access to an Amazon EKS cluster.

Enable Kubecost add-on from AWS console

After subscribing to Kubecost on AWS Marketplace and following the on-screen instructions successfully, you are redirected to Amazon EKS console. To get started in the Amazon EKS console, go to your EKS clusters, and in the Add-ons tab, select Get more add-ons to find Kubecost EKS add-ons in the cluster setting of your existing EKS clusters. You can use the search bar to find "Kubecost - Amazon EKS cost monitoring" and follow the on-screen instructions to enable Kubecost add-on for your Amazon EKS cluster. You can learn more about direct deployment to Amazon EKS clusters from this AWS blog post.

Enable Kubecost add-on using AWS CLI

On your workspace, run the following command to enable the Kubecost add-on for your Amazon EKS cluster:

aws eks create-addon --addon-name kubecost_kubecost --cluster-name $YOUR_CLUSTER_NAME --region $AWS_REGION

{
    "addon": {
        "addonName": "kubecost_kubecost",
        "clusterName": "$YOUR_CLUSTER_NAME",
        "status": "CREATING",
        "addonVersion": "v1.97.0-eksbuild.1",
        "health": {
            "issues": []
        },
        "addonArn": "arn:aws:eks:$AWS_REGION:xxxxxxxxxxxx:addon/$YOUR_CLUSTER_NAME/kubecost_kubecost/90c23198-cdd3-b295-c410-xxxxxxxxxxxx",
        "createdAt": "2022-12-01T12:18:26.497000-08:00",
        "modifiedAt": "2022-12-01T12:50:52.222000-08:00",
        "tags": {}
    }
}

To monitor the installation status, you can run the following command:

aws eks describe-addon --addon-name kubecost_kubecost --cluster-name $YOUR_CLUSTER_NAME --region $AWS_REGION

{
    "addon": {
        "addonName": "kubecost_kubecost",
        "clusterName": "$YOUR_CLUSTER_NAME",
        "status": "ACTIVE",
        "addonVersion": "v1.97.0-eksbuild.1",
        "health": {
            "issues": []
        },
        "addonArn": "arn:aws:eks:$AWS_REGION:xxxxxxxxxxxx:addon/$YOUR_CLUSTER_NAME/kubecost_kubecost/90c23198-cdd3-b295-c410-xxxxxxxxxxxx",
        "createdAt": "2022-12-01T12:18:26.497000-08:00",
        "modifiedAt": "2022-11-10T12:53:21.140000-08:00",
        "tags": {}
    }
}

The Kubecost add-on should be available in a few minutes. Run the following command to enable port-forwarding to expose the Kubecost dashboard:

kubectl port-forward --namespace kubecost deployment/kubecost-cost-analyzer 9090

Disable Kubecost add-on

To disable Kubecost add-on, you can run the following command:

aws eks delete-addon --addon-name kubecost_kubecost --cluster-name $YOUR_CLUSTER_NAME --region $AWS_REGION

Deploying Kubecost on an Amazon EKS cluster using Helm

To get started, you can follow these steps to deploy Kubecost into your Amazon EKS cluster in a few minutes using Helm.

Prerequisites:

• Install the following tools: Helm 3.9+, kubectl, and optionally eksctl and AWS CLI.

• You have access to an Amazon EKS cluster.

• If your cluster is version 1.23 or later, you must have the Amazon EBS CSI driver installed on your cluster. You can also follow these instructions to install Amazon EBS CSI driver:

1. Run the following command to create an IAM service account with the policies needed to use the Amazon EBS CSI Driver.

eksctl create iamserviceaccount   \
    --name ebs-csi-controller-sa   \
    --namespace kube-system   \
    --cluster $CLUSTER_NAME   \
    --attach-policy-arn arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy  \
    --approve \
    --role-only \
    --role-name AmazonEKS_EBS_CSI_DriverRole
export SERVICE_ACCOUNT_ROLE_ARN=$(aws iam get-role --role-name AmazonEKS_EBS_CSI_DriverRole --output json | jq -r '.Role.Arn')

1. Install the Amazon EBS CSI add-on for EKS using the AmazonEKS_EBS_CSI_DriverRole by issuing the following command:

eksctl create addon --name aws-ebs-csi-driver --cluster $CLUSTER_NAME \
    --service-account-role-arn $SERVICE_ACCOUNT_ROLE_ARN --force

After completing these prerequisite steps, you're ready to begin EKS integration.

Step 1: Install Kubecost on your Amazon EKS cluster

In your environment, run the following command from your terminal to install Kubecost on your existing Amazon EKS cluster:

helm upgrade -i kubecost \
oci://public.ecr.aws/kubecost/cost-analyzer --version <$VERSION> \
--namespace kubecost --create-namespace \
-f https://raw.githubusercontent.com/kubecost/cost-analyzer-helm-chart/develop/cost-analyzer/values-eks-cost-monitoring.yaml

To install Kubecost on Amazon EKS cluster on AWS Graviton2 (ARM-based processor), you can run following command:

helm upgrade -i kubecost \
oci://public.ecr.aws/kubecost/cost-analyzer --version <$VERSION> \
--namespace kubecost --create-namespace \
-f https://raw.githubusercontent.com/kubecost/cost-analyzer-helm-chart/develop/cost-analyzer/values-eks-cost-monitoring.yaml \
--set prometheus.configmapReload.prometheus.image.repository=jimmidyson/configmap-reload \
--set prometheus.configmapReload.prometheus.image.tag=v0.7.1

By default, the installation will include certain prerequisite software including Prometheus and kube-state-metrics. To customize your deployment, such as skipping these prerequisites if you already have them running in your cluster, you can configure any of the available values to modify storage, network configuration, and more.

Step 2: Generate Kubecost dashboard endpoint

Run the following command to enable port-forwarding to expose the Kubecost dashboard:

kubectl port-forward --namespace kubecost deployment/kubecost-cost-analyzer 9090

Step 3: Access Monitoring dashboards

You can now access Kubecost's UI by visiting http://localhost:9090 in your local web browser. Here, you can monitor your Amazon EKS cluster cost and efficiency. Depending on your organization’s requirements and setup, you may have different options to expose Kubecost for internal access. There are a few examples that you can use for your references:

• See Kubecost's Ingress Examples doc as a reference for using Nginx ingress controller with basic auth.

• You can also consider using AWS LoadBalancer controller to expose Kubecost and use Amazon Cognito for authentication, authorization, and user management. You can learn more via the AWS blog post Authenticate Kubecost Users with Application Load Balancer and Amazon Cognito.

Deploying Kubecost on an EKS Anywhere cluster using Helm

Amazon EKS Anywhere (EKS-A) is an alternate deployment of EKS which allows you to create and configure on-premises clusters, including on your own virtual machines. It is possible to deploy Kubecost on EKS-A clusters to monitor spend data.

Prerequisites:

• Install the following tools: Helm 3.9+, kubectl, and eksctl (only for EKS-A installation).

• You have installed the EKS-A installer and have access to an Amazon EKS-A cluster.

Step 1: Install Kubecost on your Amazon EKS cluster

In your environment, run the following command from your terminal to install Kubecost on your existing Amazon EKS cluster:

helm upgrade -i kubecost \
oci://public.ecr.aws/kubecost/cost-analyzer --version <$VERSION> \
--namespace kubecost --create-namespace \
-f https://raw.githubusercontent.com/kubecost/cost-analyzer-helm-chart/develop/cost-analyzer/values-eks-cost-monitoring.yaml

To install Kubecost on an EKS-A cluster on AWS Graviton2 (ARM-based processor), you can run following command:

helm upgrade -i kubecost \
oci://public.ecr.aws/kubecost/cost-analyzer --version <$VERSION> \
--namespace kubecost --create-namespace \
-f https://raw.githubusercontent.com/kubecost/cost-analyzer-helm-chart/develop/cost-analyzer/values-eks-cost-monitoring.yaml \
--set prometheus.configmapReload.prometheus.image.repository=jimmidyson/configmap-reload \
--set prometheus.configmapReload.prometheus.image.tag=v0.7.1

By default, the installation will include certain prerequisite software including Prometheus and kube-state-metrics. To customize your deployment, such as skipping these prerequisites if you already have them running in your cluster, you can configure any of the available values to modify storage, network configuration, and more.

Step 2: Generate Kubecost dashboard endpoint

Run the following command to enable port-forwarding to expose the Kubecost dashboard:

kubectl port-forward --namespace kubecost deployment/kubecost-cost-analyzer 9090

Step 3: Access Monitoring dashboards

You can now access Kubecost's UI by visiting http://localhost:9090 in your local web browser. Here, you can monitor your Amazon EKS cluster cost and efficiency through the Allocations and Assets pages.

Additional resources

Amazon EKS documentation:

• Amazon EKS cost monitoring

• Amazon EKS add-on

• Amazon EKS Anywhere

AWS blog content:

• AWS and Kubecost collaborate to deliver cost monitoring for EKS customers

• New – AWS Marketplace for Containers Now Supports Direct Deployment to Amazon EKS Clusters

This article is the primary reference for installing Kubecost in an air-gapped environment with a user-managed container registry.

Kubecost images

This section details all required and optional Kubecost images. Optional images are used depending on the specific configuration needed.

Please substitute the appropriate version for prod-x.xx.x. .

To find the exact images used for each Kubecost release, a command such as this can be used:

Kubecost: Required

• Frontend: gcr.io/kubecost1/frontend

• CostModel: gcr.io/kubecost1/cost-model

Kubecost: Optional

• NetworkCosts: gcr.io/kubecost1/kubecost-network-costs (used for )

• Cluster controller: gcr.io/kubecost1/cluster-controller:v0.9.0 (used for write actions)

• BusyBox: registry.hub.docker.com/library/busybox:latest (only for NFS)

Prometheus: Required when bundled

• quay.io/prometheus/prometheus

• prom/node-exporter

• quay.io/prometheus-operator/prometheus-config-reloader

Grafana: Optional

• grafana/grafana

• kiwigrid/k8s-sidecar

Thanos: Optional

• thanosio/thanos

FAQ and troubleshooting

How do I configure prices for my on-premise assets?

There are two options to configure asset prices in your on-premise Kubernetes environment:

Simple pipeline

Advanced pipeline

This method allows each individual asset in your environment to have a unique price. This leverages the Kubecost custom CSV pipeline which is available on Enterprise plans.

I use AWS and want the public pricing but can't allow Kubecost to ingress/egress data

Kubecost supports deploying to Red Hat OpenShift (OCP) and includes options and features which assist in getting Kubecost running quickly and easily with OpenShift-specific resources.

Deployment options

There are two main options to deploy Kubecost on OpenShift.

More details and instructions on both deployment options are covered in the sections below.

Standard deployment guide

Overview

A standard deployment of Kubecost to OpenShift is no different from deployments to other platforms with the exception of additional settings which may be required to successfully deploy to OpenShift.

Kubecost is installed with Cost Analyzer and Prometheus as a time-series database. Data is gathered by the Prometheus instance bundled with Kubecost. Kubecost then pushes and queries metrics to and from Prometheus.

The standard deployment is illustrated in the following diagram.

Prerequisites

• An existing OpenShift or OpenShift-compatible cluster (ex., OKD).

• Access to the cluster to create a new project and deploy new workloads.

• helm CLI installed locally.

Installation

Add the Kubecost Helm chart repository and scan for new charts.

Install Kubecost using OpenShift specific values. Note that the below command fetches the OpenShift values from the development branch which may not reflect the state of the release which was just installed. We recommend using the corresponding values file from the chart release.

Because OpenShift disallows defining certain fields in a pod's securityContext configuration, values specific to OpenShift must be used. The necessary values have already been defined in the OpenShift values file but may be customized to your specific needs.

If you want to install Kubecost with your desired cluster name, provide the following values to either your values override file or via the --set command. Remember to replace the cluster name/id with the value you wish to use for this installation.

After installation, wait for all pods to be ready. Kubecost will begin collecting data and may take up to 15 minutes for the UI to reflect the resources in the local cluster.

Community operator deployment guide

Overview

Prerequisites

• An existing OpenShift cluster.

• Access to the cluster to create a new project and deploy new workloads.

Installation

Log in to your OCP cluster web console and select Operators > OperatorHub > then enter "Kubecost" in the search box.

Click the Install button to be taken to the operator installation page.

On the installation page, select the update approval method and then click Install.

Once the operator has been installed, create a namespace in which to deploy a Kubecost installation.

You can also select Operators > Installed Operators to review the details as shown below.

Once the namespace has been created, create the CostAnalyzer Custom Resource (CR) with the desired values for your installation. The CostAnalyzer CR represents the total Helm values used to deploy Kubecost and any of its components. This may either be created in the OperatorHub portal or via the oc CLI. The default CostAnalyzer sample provided is pre-configured for a basic installation of Kubecost.

To create the CostAnalyzer resource from OperatorHub, from the installed Kubecost operator page, click on the CostAnalyzer tab and click the Create CostAnalyzer button.

Click on the radio button YAML view to see a full example of a CostAnalyzer CR. Here, you can either create a CostAnalyzer directly or download the Custom Resource for later use.

Change the namespace field to kubecost if this was the name of your namespace created previously.

Click the Create button to create the CostAnalyzer based on the current YAML.

After about a minute, Kubecost should be up and running based upon the configuration defined in the CostAnalyzer CR. You can get details on this installation by clicking on the instance which was just deployed.

is a free, open-source tool that enables you to deploy Kubecost on Kubernetes with the cloud provider of your choice. Plural is an open-source DevOps platform for self-hosting applications on Kubernetes without the management overhead. With baked-in SSO, automated upgrades, and secret encryption, you get all the benefits of a managed service with none of the lock-in or cost.

Kubecost is available as direct install with Plural, and it synergizes very well with the ecosystem, providing cost monitoring out of the box to users that deploy their Kubernetes clusters with Plural.

Getting started

First, create an account on . This is only to track your installations and allow for the delivery of automated upgrades. You will not be asked to provide any infrastructure credentials or sensitive information.

Next, install the Plural CLI by following steps 1-3 of .

You'll need a Git repository to store your Plural configuration. This will contain the Helm charts, Terraform config, and Kubernetes manifests that Plural will autogenerate for you.

You have two options:

• Run plural init in any directory to let Plural initiate an OAuth workflow to create a Git repo for you.

• Create a Git repo manually, clone it down, and run plural init inside it.

Running plural init will start a configuration wizard to configure your Git repo and cloud provider for use with Plural. You're now ready to install Kubecost on your Plural repo.

Installing Kubecost

To find the console bundle name for your cloud provider, run:

Now, to add it your workspace, run the install command. If you're on AWS, this is what the command would look like:

Plural's Kubecost distribution has support for AWS, GCP, and Azure, so feel free to pick whichever best fits your infrastructure.

To generate the configuration and deploy your infrastructure, run:

Note: Deploys will generally take 10-20 minutes, based on your cloud provider.

Installing the Plural Console

To make management of your installation as simple as possible, we recommend installing the Plural Console. The console provides tools to manage resource scaling, receiving automated upgrades, creating dashboards tailored to your Kubecost installation, and log aggregation. This can be done using the exact same process as above, using AWS as an example:

Accessing your Kubecost installation

Now, head over to kubecost.YOUR_SUBDOMAIN.onplural.sh to access the Kubecost UI. If you set up a different subdomain for Kubecost during installation, make sure to use that instead.

Accessing your Plural Console

To monitor and manage your Kubecost installation, head over to the Plural Console at console.YOUR_SUBDOMAIN.onplural.sh.

Uninstalling Kubecost on Plural

To bring down your Plural installation of Kubecost at any time, run:

To bring your entire Plural deployment down, run:

Note: Only do this if you're absolutely sure you want to bring down all associated resources with this repository.

Troubleshooting

Further reading