### Install kubectl-cost using Krew

Source: https://opencost.io/docs/integrations/kubectl-cost

Install the kubectl-cost plugin using the Krew plugin manager. This is the recommended installation method if Krew is already set up.

```bash
kubectl krew install cost
```

--------------------------------

### Install OpenCost using Manifest on STACKIT

Source: https://opencost.io/docs/configuration/stackit

Installs OpenCost on STACKIT using the Helm chart after adding and updating the repository. Assumes the opencost namespace will be created.

```bash
helm install opencost opencost/opencost --namespace opencost --create-namespace
```

--------------------------------

### Install OpenCost using Helm Chart

Source: https://opencost.io/docs/configuration/otc

Installs OpenCost using its Helm chart with custom settings defined in a `local.yaml` file. This is the recommended installation method.

```bash
helm install opencost --repo https://opencost.github.io/opencost-helm-chart opencost \
  --namespace opencost -f local.yaml
```

--------------------------------

### Clone and Start OpenCost with MCP Server (Tilt)

Source: https://opencost.io/docs/integrations/mcp

Clone the OpenCost repository and start the development environment using Tilt. The MCP server is enabled by default.

```bash
# Clone and start OpenCost with MCP server  

git clone https://github.com/opencost/opencost.git  

cd opencost  

tilt up  

```

--------------------------------

### Create and Start Diagnostics Export Controller

Source: https://opencost.io/docs/developer/export-api

Initializes and starts the diagnostics exporter with a specified export frequency. Includes setup for a diagnostic service and file storage.

```go
package main

import (

    "context"

    "math/rand"

    "os"

    "os/signal"

    "syscall"

    "time"


    "github.com/opencost/opencost/core/pkg/diagnostics"

    "github.com/opencost/opencost/core/pkg/storage"

    diagexporter "github.com/opencost/opencost/core/pkg/diagnostics/exporter"

)

const (

    ClusterID = "MyClusterID" 

    ApplicationName = "MyApplication"


    ExportFrequency time.Duration = 10 * time.Second

)

// entry point for finops-agent
func main() {

    diag := diagnostics.NewDiagnosticService()


    // register a faux diagnostic runner that will flip a coin

    diag.Register(

        "coin-flip",

        "A randomized diagnostic result",

        "random",

        func(ctx context.Context) (map[string]any, error) {

            result := "tails"

            if rand.Intn(2) == 1 {

                result = "heads"

            }


            return map[string]any{

                "result": result,

            }, nil

        },

    )


    // create a file storage located in the /tmp directory (this will ultimately produce /tmp/<cluster-id>/diagnostics/<application-name>/<time>.json files)

    fileStorage := storage.NewFileStorage("/tmp")


    // diagnostics exporter running every 10 seconds

    diagnosticsExporter := diagexporter.NewDiagnosticsExportController(ClusterID, ApplicationName, fileStorage, diag)

    diagnosticsExporter.Start(ExportFrequency)


    WaitForSignal()

}

// WaitForSignal waits for a termination signal (SIGINT or SIGTERM) and then exits the program.
func WaitForSignal() {

    signalChan := make(chan os.Signal, 1)

    signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)


    done := make(chan struct{}, 1)


    go func() {

        defer close(done)

        <-signalChan

    }()


    <-done

}

```

--------------------------------

### Install Prometheus

Source: https://opencost.io/docs/configuration/otc

Installs Prometheus using the official Helm chart. This is a prerequisite for OpenCost. Ensure Prometheus is installed in the `prometheus-system` namespace with default settings for OpenCost.

```bash
helm install prometheus --repo https://prometheus-community.github.io/helm-charts prometheus \
  --namespace prometheus-system --create-namespace \
  --set prometheus-pushgateway.enabled=false \
  --set alertmanager.enabled=false \
  -f https://raw.githubusercontent.com/opencost/opencost/develop/kubernetes/prometheus/extraScrapeConfigs.yaml
```

--------------------------------

### Install kubectl-cost Manually

Source: https://opencost.io/docs/integrations/kubectl-cost

Manually install the kubectl-cost plugin by downloading the latest release and placing it in your system's PATH. This method is suitable if Krew is not installed.

```bash
os=$(uname | tr '[:upper:]' '[:lower:]') && \
arch=$(uname -m | tr '[:upper:]' '[:lower:]' | sed -e s/x86_64/amd64/) && \
curl -s -L https://github.com/kubecost/kubectl-cost/releases/latest/download/kubectl-cost-$os-$arch.tar.gz | tar xz -C /tmp && \
chmod +x /tmp/kubectl-cost && \
sudo mv /tmp/kubectl-cost /usr/local/bin/kubectl-cost
```

--------------------------------

### Example OpenCost Helm Configuration

Source: https://opencost.io/docs/installation/helm

This is an example `values.yaml` file demonstrating various configuration options for OpenCost, including Prometheus integration, data retention, exporter settings, custom pricing, and UI enablement.

```yaml
opencost:
  prometheus:
    internal:
      namespaceName: monitoring
      serviceName: prometheus-kube-prometheus-prometheus
      port: 9090
  
  dataRetention:
    dailyResolutionDays: 30  # default: 15
  
  exporter:
    defaultClusterId: <cluster name>
    replicas: 1
    resources:
      requests:
        cpu: "10m"
        memory: "55Mi"
      limits:
        memory: "1Gi"
    persistence:
      enabled: true
      storageClass: "csi-cinder-high-speed"  # adjust based on your environment
      accessMode: ReadWriteOnce
      size: 5Gi
  
  customPricing:
    enabled: true
    provider: aws
    costModel:
      description: Modified pricing configuration.
      CPU: 0.031611
      spotCPU: 0.006655
      RAM: 0.004237
      spotRAM: 0.000892
      GPU: 0.95
      storage: 0.00005479452
      zoneNetworkEgress: 0.01
      regionNetworkEgress: 0.01
      internetNetworkEgress: 0.143
      spotLabel: ""
      spotLabelValue: ""
      awsServiceKeyName: ""
      awsServiceKeySecret: ""
      awsSpotDataRegion: ""
      awsSpotDataBucket: ""
      awsSpotDataPrefix: ""
      athenaBucketName: ""
      athenaRegion: ""
      athenaDatabase: ""
      athenaTable: ""
      projectID: "${ACCOUNT_ID}"
  
  metrics:
    kubeStateMetrics:
      emitKsmV1Metrics: false
      emitKsmV1MetricsOnly: false
    serviceMonitor:
      enabled: true
      additionalLabels:
        release: prometheus
  
  ui:
    enabled: true

```

--------------------------------

### Start Tilt Development Environment

Source: https://opencost.io/docs/installation/development

Starts the Tilt development environment for OpenCost. Tilt will automatically watch for changes and redeploy as needed. Ensure you are in the root of the OpenCost repository.

```bash
tilt up
```

--------------------------------

### Add OpenCost Helm Repository and Install

Source: https://opencost.io/docs/configuration/otc

Adds the OpenCost Helm repository and then installs OpenCost using the chart. This is an alternative method for installing OpenCost, especially when not using a custom `local.yaml`.

```bash
helm repo add opencost https://opencost.github.io/opencost-helm-chart
helm repo update
helm install opencost opencost/opencost --namespace opencost --create-namespace
```

--------------------------------

### AWS Provider Configuration Example

Source: https://opencost.io/docs/configuration/aws

An example of the AWS provider configuration file for OpenCost. This includes settings for spot instance data, regions, buckets, and project ID.

```json
{
    "provider": "aws",
    "description": "AWS Provider Configuration. Provides default values used if instance type or spot information is not found.",
    "CPU": "0.031611",
    "spotCPU": "0.006655",
    "RAM": "0.004237",
    "GPU": "0.95",
    "spotRAM": "0.000892",
    "storage": "0.000138888889",
    "zoneNetworkEgress": "0.01",
    "regionNetworkEgress": "0.01",
    "internetNetworkEgress": "0.143",
    "spotLabel": "kops.k8s.io/instancegroup",
    "spotLabelValue": "spotinstance-nodes",
    "awsSpotDataRegion":"us-east-2",
    "awsSpotDataBucket": "my-spot-bucket",
    "awsSpotDataPrefix": "spot_pricing_prefix",
    "projectID": "012345678901"
}
```

--------------------------------

### Run Docker Compose

Source: https://opencost.io/docs/installation/docker

Starts the OpenCost services defined in the 'opencost.yml' file using Docker Compose.

```bash
docker compose -f opencost.yml up
```

--------------------------------

### Install Prometheus OpenCost Exporter Helm Chart

Source: https://opencost.io/docs/integrations/opencost-exporter

Installs the prometheus-opencost-exporter chart from the Prometheus Community repository. Replace [RELEASE_NAME] with your desired release name.

```bash
helm install [RELEASE_NAME] prometheus-community/prometheus-opencost-exporter
```

--------------------------------

### Install OpenCost with Helm

Source: https://opencost.io/docs/installation/helm

Install OpenCost into your Kubernetes cluster using the Helm chart. It's recommended to create a custom values file for configuration and specify the namespace.

```bash
helm install opencost opencost-charts/opencost --namespace opencost --create-namespace -f values.yaml
```

--------------------------------

### Install OpenCost Exporter

Source: https://opencost.io/docs/integrations/opencost-exporter

Apply the combined YAML to deploy the OpenCost exporter in the opencost-exporter namespace.

```bash
kubectl apply --namespace opencost-exporter \
-f https://raw.githubusercontent.com/opencost/opencost/develop/kubernetes/exporter/opencost-exporter.yaml
```

--------------------------------

### Create OpenCost Namespace

Source: https://opencost.io/docs/configuration/ovh

Use this command to create the 'opencost' namespace for your installation.

```bash
kubectl create namespace opencost  
```

--------------------------------

### Register and Run Diagnostics

Source: https://opencost.io/docs/developer/diagnostics-api

This example demonstrates how to create a new diagnostic service, register a custom diagnostic with a name, description, category, and an execution function. It also shows how to run all registered diagnostics with a timeout context and process the results.

```go
package main  
  
import (  
    "context"  
    "fmt"  
    "time"  
      
    "github.com/opencost/opencost/core/pkg/diagnostics"  
)  
  
func main() {  
    const (  
        DiagnosticCategorySystem = "system"  
    )  
  
    // Create service  
    diagService := diagnostics.NewDiagnosticService()  
      
    // Register diagnostics  
diagService.Register(  
        "config-check",  
        "Validates system configuration",  
        DiagnosticCategorySystem,  
        func(ctx context.Context) (map[string]any, error) {  
            // run actual diagnostics of configuration checks and report back the  
            // results...   
            return map[string]any{  
                "configValid": true,  
                "lastUpdated": time.Now().Add(-24 * time.Hour),  
            }, nil  
        },  
    )  
      
    // Run ALL diagnostics with 10 second timeout -- Important to note that   
    // each diagnostic is limited to a 5 second execution time  
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)  
    defer cancel()  
      
    results := diagService.Run(ctx)  
      
    // Process results  
    for _, r := range results {  
        if r.Error != "" {  
            fmt.Printf("❌ %s: %s\n", r.Name, r.Error)  
        } else {  
            fmt.Printf("✅ %s: %v\n", r.Name, r.Details)  
        }  
    }  
}  
```

--------------------------------

### Example Prometheus Configuration for Thanos

Source: https://opencost.io/docs/installation/multi-cluster-single-source-of-data

Example Prometheus configuration snippet showing how to set external labels, which are used by OpenCost for cluster identification when using a shared backend like Thanos.

```yaml
externalLabels:
  cluster: qa
```

--------------------------------

### List Cost per Provider and Service for 14 Days

Source: https://opencost.io/docs/integrations/api-examples

This example demonstrates multi-aggregation by Provider and Service to list costs for the past 14 days. The provided JSON output shows a sample response structure.

```bash
curl -G http://localhost:9003/cloudCost \
  -d window=14d \
  -d aggregate=provider,service
```

```json
{
  "code": 200,
  "data": {
    "sets": [
      {
        "cloudCosts": {
          "AWS/AWSBackup": { ... },
          "AWS/AWSCloudTrail": {
            "properties": {
              "provider": "AWS",
              "invoiceEntityID": "297945954695",
              "service": "AWSCloudTrail",
              "category": "Other"
            },
            "window": {
              "start": "2023-10-28T00:00:00Z",
              "end": "2023-10-29T00:00:00Z"
            },
            "listCost": {
              "cost": 19.800393,
              "kubernetesPercent": 0
            },
            "netCost": {
              "cost": 19.800393,
              "kubernetesPercent": 0
            },
            "amortizedNetCost": {
              "cost": 19.800393,
              "kubernetesPercent": 0
            },
            "invoicedCost": {
              "cost": 19.800393,
              "kubernetesPercent": 0
            },
            "amortizedCost": {
              "cost": 19.800393,
              "kubernetesPercent": 0
            }
          },
          "AWS/AWSCostExplorer": { ... },
          "AWS/AWSELB": { ... },
          "AWS/AWSGlobalAccelerator": { ... },
          "...": "...",
          "GCP/Secret Manager": { ... }
        },
        "aggregationProperties": [
          "provider",
          "service"
        ]
      }
    ],
    "window": {
      "start": "null",
      "end": "null"
    }
  }
}
```

--------------------------------

### Example EventExporter Implementation

Source: https://opencost.io/docs/developer/export-api

An example of an EventExporter implementation that stores JSON encoded Message objects to an in-memory file system. It demonstrates the creation of storage, path formatter, encoder, and the exporter itself.

```go
package main

import (
    "time"

    "github.com/opencost/opencost/core/pkg/exporter"
    "github.com/opencost/opencost/core/pkg/storage"
    "github.com/opencost/opencost/core/pkg/exporter/pathing"
)

// constants we'll use in our example for our cluster identifier and event name
const (
    ClusterId = "cluster-01"
    MessageEventName = "message"
)

// Our 'T' type is a simple struct that contains a message string
type Message struct {
    Message string `json:"message"`
}

func main() {
    // create the storage.Storage implementation, an in-memory file system 
    store := storage.NewMemoryStorage()

    // create a pathing.StoragePathFormatter implementation specially for exporting "events" 
    pathFormatter, err := pathing.NewEventStoragePathFormatter("federated", ClusterId, MessageEventName)
    if err != nil {
        panic("failed to create path formatter: " + err.Error())
    }

    // create a JSON encoder for our Message type 
    encoder := exporter.NewJSONEncoder[Message]()

    // finally, create the EventStorageExporter implementation for our Message type 
    export := exporter.NewEventStorageExporter(pathFormatter, encoder, store)

    at := time.Now().UTC()

    export.Export(at, &Message{
        Message: "Testing 1, 2, 3...",
    })

}
```

```json
{
    "message": "Testing 1, 2, 3..."
}
```

--------------------------------

### All Billing Items for a 3-Day Period

Source: https://opencost.io/docs/integrations/api-examples

This example retrieves all billing items for a specific 3-day period. Be aware that this query can return a large amount of data, potentially megabytes, depending on cloud provider usage.

```bash
curl -G http://localhost:9003/cloudCost \
  -d window=2023-10-28T00:00:00Z,2023-10-31T00:00:00Z
```

--------------------------------

### Deploy OpenCost with MCP Server (Helm)

Source: https://opencost.io/docs/integrations/mcp

Deploy OpenCost using the Helm chart. The MCP server is enabled by default in this installation.

```bash
# Deploy OpenCost with MCP server (enabled by default)  

helm install opencost opencost/opencost  

```

--------------------------------

### Example Error Message for Allocation API

Source: https://opencost.io/docs/troubleshooting

This is an example of an error message that may appear when the allocation API fails to query.

```text
Error: failed to query allocation API: failed to port forward query: received non-200 status code 500 and data: {"code":500,"status":"","data":null,"message":"Error: error computing allocation for ...  

```

--------------------------------

### Allocation Data with Distributed Idle Costs

Source: https://opencost.io/docs/integrations/api-examples

This example demonstrates how to query allocation data for the last day while distributing cluster idle costs across all allocations.

```APIDOC
## GET /allocation

### Description
Retrieves allocation data for a specified time window, with cluster idle costs distributed across all allocations.

### Method
GET

### Endpoint
/allocation

### Parameters
#### Query Parameters
- **window** (string) - Required - The time window for the data (e.g., 1d).
- **shareIdle** (boolean) - Required - Set to `true` to distribute cluster idle costs.

### Request Example
```
curl -G http://localhost:9003/allocation \
  -d window=1d \
  -d shareIdle=true
```
```

--------------------------------

### Default OpenCost UI Allocation Request

Source: https://opencost.io/docs/integrations/api-examples

This example demonstrates a default query for the OpenCost UI, retrieving allocation data for the last 7 days with a 1-minute resolution, aggregated by namespace.

```APIDOC
## GET /allocation

### Description
Retrieves allocation data for a specified time window with configurable aggregation and resolution.

### Method
GET

### Endpoint
/allocation

### Parameters
#### Query Parameters
- **window** (string) - Required - The time window for the data (e.g., 7d).
- **aggregate** (string) - Required - The field to aggregate data by (e.g., namespace).
- **resolution** (string) - Required - The resolution of the data (e.g., 1m).

### Request Example
```
curl -G http://localhost:9003/allocation \
  -d window=7d \
  -d aggregate=namespace \
  -d resolution=1m
```
```

--------------------------------

### Allocation Data with Custom Step and Resolution

Source: https://opencost.io/docs/integrations/api-examples

This example shows how to fetch allocation data for the last 60 minutes, with data points every 10 minutes and a 1-minute resolution, aggregated by namespace. It also includes a sample JSON response.

```APIDOC
## GET /allocation

### Description
Retrieves allocation data with specific step and resolution settings, aggregated by namespace.

### Method
GET

### Endpoint
/allocation

### Parameters
#### Query Parameters
- **window** (string) - Required - The time window for the data (e.g., 60m).
- **step** (string) - Required - The interval between data points (e.g., 10m).
- **resolution** (string) - Required - The resolution of the data (e.g., 1m).
- **aggregate** (string) - Required - The field to aggregate data by (e.g., namespace).

### Request Example
```
curl -G http://localhost:9003/allocation \
  -d window=60m \
  -d step=10m \
  -d resolution=1m \
  -d aggregate=namespace
```

### Response
#### Success Response (200)
- **code** (integer) - The HTTP status code.
- **data** (array) - An array containing aggregated allocation data.

#### Response Example
```json
{
  "code": 200,
  "data": [
    {
      "kube-system": { ... },
      "default": { ... },
      "cost-model": { ... }
    }
  ]
}
```
```

--------------------------------

### Custom Pricing Configuration via Helm Chart

Source: https://opencost.io/docs/configuration/on-prem

Applies custom pricing by updating the OpenCost Helm values file. This example shows how to enable custom pricing and define specific costs for CPU, RAM, and storage.

```yaml
opencost:
  customPricing:
    enabled: true
    costModel:
      description: Modified prices based on your internal pricing
      CPU: 1.25
      RAM: 0.50
      storage: 0.25
```

--------------------------------

### Upgrade OpenCost with Helm

Source: https://opencost.io/docs/configuration/azure

Upgrade the OpenCost installation using the Helm chart with the modified 'values.yaml' file.

```bash
helm upgrade opencost . --namespace opencost -f values.yaml
```

--------------------------------

### Create OpenCost Namespace

Source: https://opencost.io/docs/configuration/otc

Creates the `opencost` namespace in Kubernetes, which is required for the OpenCost installation. Alternate namespaces can be used if necessary.

```bash
kubectl create namespace opencost
```

--------------------------------

### Allocation Data with Node-Specific Idle Cost Distribution

Source: https://opencost.io/docs/integrations/api-examples

This example shows how to query allocation data for the last day, distributing idle costs on a per-node basis across all allocations on that node.

```APIDOC
## GET /allocation

### Description
Retrieves allocation data for a specified time window, with idle costs distributed on a per-node basis across allocations on that node.

### Method
GET

### Endpoint
/allocation

### Parameters
#### Query Parameters
- **window** (string) - Required - The time window for the data (e.g., 1d).
- **shareIdle** (boolean) - Required - Set to `true` to distribute idle costs.
- **idleByNode** (boolean) - Required - Set to `true` to distribute idle costs per node.

### Request Example
```
curl -G http://localhost:9003/allocation \
  -d window=1d \
  -d shareIdle=true \
  -d idleByNode=true
```
```

--------------------------------

### Allocation Data with Longer Step and Resolution

Source: https://opencost.io/docs/integrations/api-examples

This example retrieves allocation data over a 9-day period, with data points every 3 days and a 10-minute resolution, aggregated by namespace. It includes a sample JSON response.

```APIDOC
## GET /allocation/compute

### Description
Retrieves allocation data for compute resources over a longer time window with a specific step and resolution, aggregated by namespace.

### Method
GET

### Endpoint
/allocation/compute

### Parameters
#### Query Parameters
- **window** (string) - Required - The time window for the data (e.g., 9d).
- **step** (string) - Required - The interval between data points (e.g., 3d).
- **resolution** (string) - Required - The resolution of the data (e.g., 10m).
- **aggregate** (string) - Required - The field to aggregate data by (e.g., namespace).

### Request Example
```
curl -G http://localhost:9003/allocation/compute \
  -d window=9d \
  -d step=3d \
  -d resolution=10m \
  -d aggregate=namespace
```

### Response
#### Success Response (200)
- **code** (integer) - The HTTP status code.
- **data** (array) - An array containing aggregated allocation data for each step.

#### Response Example
```json
{
  "code": 200,
  "data": [
    {
      "default": { ... },
      "open-cost": { ... },
      "kube-system": { ... }
    },
    {
      "default": { ... },
      "open-cost": { ... },
      "kube-system": { ... }
    },
    {
      "default": { ... },
      "open-cost": { ... },
      "kube-system": { ... }
    }
  ]
}
```
```

--------------------------------

### Get Projected Monthly Namespace Costs (Last 2 Hours)

Source: https://opencost.io/docs/integrations/kubectl-cost

Calculate the total projected monthly costs for namespaces based on data from the last two hours, including efficiency metrics.

```bash
kubectl cost --service-port 9003 --service-name opencost --kubecost-namespace opencost --allocation-path /allocation/compute \
    namespace \
    --window 2h \
    --show-efficiency=true
```

--------------------------------

### Querying Cost Data with MCP Client

Source: https://opencost.io/docs/integrations/mcp

Examples of using the MCP client to retrieve allocation costs, asset costs, and cloud costs. These snippets show how to specify time windows, aggregation methods, and filters for cloud cost data.

```javascript
// Get cost allocation for the last 7 days  

const allocation = await mcpClient.callTool('get_allocation_costs', {  

  window: '7d',  

  aggregate: 'namespace,node'  

});  

  

// Get asset costs for the last 24 hours  

const assets = await mcpClient.callTool('get_asset_costs', {  

  window: '1d'  

});  

  

// Get cloud costs for AWS EC2 in us-west-1  

const cloudCosts = await mcpClient.callTool('get_cloud_costs', {  

  window: '7d',  

  aggregate: 'service',  

  provider: 'aws',  

  service: 'ec2',  

  accumulate: 'day',  

  filter: 'regionID:"us-west-1"'  

});  
```

--------------------------------

### Configure OpenCost Environment Variables (Helm)

Source: https://opencost.io/docs/configuration/azure

For OpenCost installations using the Helm chart, update your values.yaml file to include the Azure billing account and offer IDs within the opencost.exporter.extraEnv section.

```yaml
opencost:
  exporter:
    extraEnv:
      AZURE_BILLING_ACCOUNT: <your billing account id>
      AZURE_OFFER_ID: <your offer id>
```

--------------------------------

### Query Allocation Data with Carbon Costs via API

Source: https://opencost.io/docs/integrations/carbon-costs

Retrieve allocation data, including carbon cost metrics, by querying the OpenCost API's `/allocation` endpoint. This example demonstrates a query for the last 24 hours, aggregated by namespace with a 1-minute resolution.

```bash
curl -G http://localhost:9003/allocation \
  -d window=24h \
  -d aggregate=namespace \
  -d resolution=1m  
```

--------------------------------

### Get OpenCost Version from Logs

Source: https://opencost.io/docs/troubleshooting

Retrieve the OpenCost version by inspecting the container logs. This command shows the initial log lines, including the version information.

```bash
$ kubectl logs -n opencost deployment/opencost | head

Defaulted container "opencost" out of: opencost, opencost-ui
2024-02-29T05:58:36.68395851Z ??? Log level set to info
2024-02-29T05:58:36.68436741Z INF Starting cost-model version 1.109.0 (fa84614)
```

--------------------------------

### Upgrade OpenCost with Helm

Source: https://opencost.io/docs/installation/helm

Upgrade an existing OpenCost installation to a new version using Helm. Ensure your `values.yaml` file is up-to-date with any new configuration options.

```bash
helm upgrade opencost opencost-charts/opencost --namespace opencost -f values.yaml
```

--------------------------------

### StoragePathFormatter Interface

Source: https://opencost.io/docs/developer/export-api

Interface for formatting storage paths for exported data. It provides methods to get the root directory and construct full file paths.

```go
// StoragePathFormatter is an interface used to format storage paths for exporting data types.

type StoragePathFormatter[T any] interface {

    // RootDir returns the root directory for the storage path.

    RootDir() string

  

    // ToFullPath returns the full path to a file name within the storage

    // directory leveraging a prefix and an incoming T type (generally a daterange or timestamp).

    ToFullPath(prefix string, in T, fileExt string) string

}
```

--------------------------------

### Allocation Data: Last 9d, 3d Steps, 10m Resolution, Aggregated by Namespace

Source: https://opencost.io/docs/integrations/api-examples

Fetches allocation data for the past 9 days, with data points every 3 days, a 10-minute resolution, and aggregated by namespace. This example uses the /allocation/compute endpoint.

```curl
curl -G http://localhost:9003/allocation/compute \
  -d window=9d \
  -d step=3d \
  -d resolution=10m \
  -d aggregate=namespace
```

```json
{
  "code": 200,
  "data": [
    {
      "default": { ... },
      "open-cost": { ... },
      "kube-system": { ... }
    },
    {
      "default": { ... },
      "open-cost": { ... },
      "kube-system": { ... }
    },
    {
      "default": { ... },
      "open-cost": { ... },
      "kube-system": { ... }
    }
  ]
}
```

--------------------------------

### Create a New Diagnostic Service Instance

Source: https://opencost.io/docs/developer/diagnostics-api

Instantiate the `DiagnosticService` using `diagnostics.NewDiagnosticService()` to manage and run diagnostics.

```go
diagService := diagnostics.NewDiagnosticService()

```

--------------------------------

### Create GCP Service Account and Keys

Source: https://opencost.io/docs/configuration/gcp

Use these commands to create a GCP service account with necessary roles and generate a JSON key for OpenCost integration.

```bash
export PROJECT_ID=$(gcloud config get-value project)

gcloud iam service-accounts create compute-viewer-opencost --display-name "Compute Read Only Account Created For OpenCost" --format json

gcloud projects add-iam-policy-binding $PROJECT_ID --member serviceAccount:compute-viewer-opencost@$PROJECT_ID.iam.gserviceaccount.com --role roles/compute.viewer

gcloud projects add-iam-policy-binding $PROJECT_ID --member serviceAccount:compute-viewer-opencost@$PROJECT_ID.iam.gserviceaccount.com --role roles/bigquery.user

gcloud projects add-iam-policy-binding $PROJECT_ID --member serviceAccount:compute-viewer-opencost@$PROJECT_ID.iam.gserviceaccount.com --role roles/bigquery.dataViewer

gcloud projects add-iam-policy-binding $PROJECT_ID --member serviceAccount:compute-viewer-opencost@$PROJECT_ID.iam.gserviceaccount.com --role roles/bigquery.jobUser

gcloud iam service-accounts keys create ./compute-viewer-opencost-key.json --iam-account compute-viewer-opencost@$PROJECT_ID.iam.gserviceaccount.com
```

--------------------------------

### Prometheus Scrape Configuration for OpenCost

Source: https://opencost.io/docs/integrations/opencost-exporter

Add this configuration to your Prometheus setup to scrape metrics from the OpenCost exporter.

```yaml
- job_name: opencost
  scrape_interval: 1m
  scrape_timeout: 10s
  metrics_path: /metrics
  scheme: http
  static_configs:
 - targets: ['opencost.opencost-exporter:9003']
```

--------------------------------

### ExportController Interface

Source: https://opencost.io/docs/developer/export-api

Defines the standard interface for all export controllers, including methods for naming, starting, and stopping the controller.

```go
type ExportController interface {
  Name() string
  Start(interval time.Duration) bool
  Stop()
}
```

--------------------------------

### Get Asset Data

Source: https://opencost.io/docs/integrations/api

Retrieves backing cost data broken down by individual assets in your cluster. This data is not yet exposed in the UI.

```APIDOC
## GET /assets

### Description
Retrieves backing cost data broken down by individual assets in your cluster.

### Method
GET

### Endpoint
`/assets`

### Parameters
#### Query Parameters
- **window** (string) - Required - Duration of time over which to query. Accepts: words like `today`, `week`, `month`, `yesterday`, `lastweek`, `lastmonth`; durations like `30m`, `12h`, `7d`; RFC3339 date pairs like `2021-01-02T15:04:05Z,2021-02-02T15:04:05Z`; Unix timestamps like `1578002645,1580681045`.
```

--------------------------------

### ComputeExportControllerGroup Management

Source: https://opencost.io/docs/developer/export-api

Demonstrates how to create and manage multiple ComputeExportController instances with different resolutions using ComputeExportControllerGroup.

```go
// Create controllers for different resolutions
hourlyController := NewComputeExportController(source, exporter, time.Hour, time.Minute)
dailyController := NewComputeExportController(source, exporter, 24*time.Hour, time.Hour)

// Group them together
group := NewComputeExportControllerGroup(hourlyController, dailyController)

// Start all controllers with the same interval
group.Start(10 * time.Minute)
```

--------------------------------

### Add and Update OpenCost Helm Repository

Source: https://opencost.io/docs/configuration/stackit

Adds the OpenCost Helm repository and updates its local cache. This is a prerequisite for installing OpenCost from the manifest.

```bash
helm repo add opencost https://opencost.github.io/opencost-helm-chart
helm repo update
```

--------------------------------

### Add Prometheus Community Helm Repository

Source: https://opencost.io/docs/installation/development

Adds the Prometheus Community Helm repository to your Helm configuration. This is a prerequisite for installing OpenCost via Helm.

```bash
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
```

--------------------------------

### Get All Billing Items for a Period

Source: https://opencost.io/docs/integrations/api-examples

Retrieve all billing items for a specified duration. This response includes detailed cost breakdowns per service and resource.

```json
{
  
  "code": 200,  

  "data": {  

    "sets": [  

      {  

        "cloudCosts": {  

          ...

          "HDEAD-B6F51B-690123/testuser-opencost/GCP/__unallocated__/Management/Kubernetes Engine": {

            "properties": {

              "provider": "GCP",

              "accountID": "testuser-opencost",

              "invoiceEntityID": "HDEAD-B6F51B-690123",

              "service": "Kubernetes Engine",

              "category": "Management",

              "labels": {

                "goog-fleet-project": "",

                "goog-k8s-cluster-location": "australia-southeast1-b",

                "goog-k8s-cluster-name": "opencost-3",

                "longlived": "opencost"

              }

            },

            "window": {

              "start": "2023-10-28T00:00:00Z",

              "end": "2023-10-29T00:00:00Z"

            },

            "listCost": {

              "cost": 2.399978,

              "kubernetesPercent": 1

            },

            "netCost": {

              "cost": 2.399978,

              "kubernetesPercent": 1

            },

            "amortizedNetCost": {

              "cost": 2.399978,

              "kubernetesPercent": 1

            },

            "invoicedCost": {

              "cost": 2.399978,

              "kubernetesPercent": 1

            },

            "amortizedCost": {

              "cost": 2.399978,

              "kubernetesPercent": 1

            }

          },

          "HDEAD-B6F51B-690123/testuser-opencost/GCP/__unallocated__/Network/Networking": {

            "properties": {

              "provider": "GCP",

              "accountID": "testuser-opencost",

              "invoiceEntityID": "HDEAD-B6F51B-690123",

              "service": "Networking",

              "category": "Network"

            },

            "window": {

              "start": "2023-10-28T00:00:00Z",

              "end": "2023-10-29T00:00:00Z"

            },

            "listCost": {

              "cost": 0.46231399999999995,

              "kubernetesPercent": 0

            },

            "netCost": {

              "cost": 0.006336000000000003,

              "kubernetesPercent": 0

            },

            "amortizedNetCost": {

              "cost": 0.006336000000000003,

              "kubernetesPercent": 0

            },

            "invoicedCost": {

              "cost": 0.006336000000000003,

              "kubernetesPercent": 0

            },

            "amortizedCost": {

              "cost": 0.006336000000000003,

              "kubernetesPercent": 0

            }

          },

          ...

          "HDEAD-B6F51B-690123/testuser-opencost/GCP/gke-opencost-3-default-pool-123456f4-kbl5/Other/Compute Engine": {

            "properties": {

              "providerID": "gke-opencost-3-default-pool-123456f4-kbl5",

              "provider": "GCP",

              "accountID": "testuser-opencost",

              "invoiceEntityID": "HDEAD-B6F51B-690123",

              "service": "Compute Engine",

              "category": "Other",

              "labels": {

                "goog-gke-node": "",

                "goog-k8s-cluster-location": "australia-southeast1-b",

                "goog-k8s-cluster-name": "opencost-3",

                "goog-k8s-node-pool-name": "default-pool",

                "longlived": "opencost"

              }

            },

            "window": {

              "start": "2023-10-28T00:00:00Z",

              "end": "2023-10-29T00:00:00Z"

            },

            "listCost": {

              "cost": 0,

              "kubernetesPercent": 0

            },

            "netCost": {

              "cost": 0,

              "kubernetesPercent": 0

            },

            "amortizedNetCost": {

              "cost": 0,

              "kubernetesPercent": 0

            },

            "invoicedCost": {

              "cost": 0,

              "kubernetesPercent": 0

            },

            "amortizedCost": {

              "cost": 0,

              "kubernetesPercent": 0

            }

          },

          ...

        "window": {

          "start": "2023-10-30T00:00:00Z",

          "end": "2023-10-31T00:00:00Z"

        },

        "aggregationProperties": [

          "invoiceEntityID",

          "accountID",

          "provider",

          "providerID",

          "category",

          "service"

        ]

      }

    ],

    "window": {

      "start": "null",

      "end": "null"

    }

  }

}

```

--------------------------------

### Get Allocation Data

Source: https://opencost.io/docs/integrations/api

Retrieves cost allocation data based on specified query parameters. This endpoint allows for aggregation and time-windowed analysis of costs.

```APIDOC
## GET /allocation

### Description
Retrieves cost allocation data, allowing aggregation by various dimensions and time windows.

### Method
GET

### Endpoint
`/allocation`

### Parameters
#### Query Parameters
- **window** (string) - Required - Duration of time over which to query. Accepts: words like `today`, `week`, `month`, `yesterday`, `lastweek`, `lastmonth`; durations like `30m`, `12h`, `7d`; RFC3339 date pairs like `2021-01-02T15:04:05Z,2021-02-02T15:04:05Z`; Unix timestamps like `1578002645,1580681045`.
- **aggregate** (string) - Optional - Field by which to aggregate the results. Accepts: `cluster`, `node`, `namespace`, `controllerKind`, `controller`, `service`, `pod`, `container`, `label:LABEL_NAME`, and `annotation:name`. Also accepts comma-separated lists for multi-aggregation, like `aggregate=namespace,label:app`.
- **step** (string) - Optional - Duration of a single allocation set. If unspecified, this defaults to the `window`. Default is `window`.
- **resolution** (string) - Optional - Duration to use as resolution in Prometheus queries. Default is `1m`.
- **includeIdle** (boolean) - Optional - Whether to return the calculated `__idle__` field for the query. Default is `false`.
- **shareIdle** (boolean) - Optional - Whether to distribute idle costs across non-idle allocations. Default is `false`.
- **idleByNode** (boolean) - Optional - Whether to calculate idle costs per node instead of per cluster. Default is `false`.
```

--------------------------------

### Deploy OpenCost with Custom MCP Port (Helm)

Source: https://opencost.io/docs/integrations/mcp

Deploy OpenCost using Helm and configure the MCP server to run on a custom port by setting `opencost.mcp.port`.

```bash
# Deploy with custom MCP port  

helm install opencost opencost/opencost  \  
  --set opencost.mcp.port=9091  

```

--------------------------------

### Upgrade Prometheus OpenCost Exporter Helm Chart

Source: https://opencost.io/docs/integrations/opencost-exporter

Upgrades an existing installation of the prometheus-opencost-exporter chart. Replace [RELEASE_NAME] and [CHART] with your release name and chart reference, respectively.

```bash
helm upgrade [RELEASE_NAME] [CHART] --install
```

--------------------------------

### Run Diagnostics Using the Service

Source: https://opencost.io/docs/developer/diagnostics-api

Execute diagnostics using the `DiagnosticService`. You can run all registered diagnostics, diagnostics within a specific category, or a single named diagnostic.

```go
// Run all diagnostics
ctx := context.Background()
allResults := diagService.Run(ctx)

// Run all diagnostics in a specific category
networkResults := diagService.RunCategory(ctx, "network")

// Run a specific diagnostic
result := diagService.RunDiagnostic(ctx, "connectivity", "connection-check")

```

--------------------------------

### Add OpenCost Helm Repository

Source: https://opencost.io/docs/installation/helm

Add the OpenCost Helm chart repository to your local Helm installation to access the chart. This command fetches the latest chart information.

```bash
helm repo add opencost-charts https://opencost.github.io/opencost-helm-chart
```

```bash
helm repo update
```

--------------------------------

### Update OpenCost via Helm

Source: https://opencost.io/docs/configuration/otc

Upgrades an existing OpenCost installation managed by Helm. This command can be used to update the Helm chart version or modify settings defined in `local.yaml`.

```bash
helm upgrade opencost --repo https://opencost.github.io/opencost-helm-chart opencost \
  --namespace opencost -f local.yaml
```

--------------------------------

### Create a Kind Kubernetes Cluster

Source: https://opencost.io/docs/installation/development

Creates a local Kubernetes cluster using `kind`. This is an optional step if you are not using `kind` or already have a Kubernetes cluster configured.

```bash
kind create cluster
```

--------------------------------

### Enable OpenCost ServiceMonitor for kube-prometheus-stack

Source: https://opencost.io/docs/configuration/ovh

Configure OpenCost's Helm chart to enable the ServiceMonitor when using kube-prometheus-stack. This allows OpenCost to integrate with an existing Prometheus Operator setup.

```yaml
opencost:
  metrics:
    serviceMonitor:
      enabled: true
      additionalLabels:
        release: <your-prometheus-stack-release-name>
```

--------------------------------

### Apply OpenCost YAML Configuration

Source: https://opencost.io/docs/configuration/azure

Apply the updated OpenCost deployment YAML to the cluster to incorporate the new volume and volume mount.

```bash
$ kubectl apply -f opencost.yaml -n opencost
```

--------------------------------

### Query OpenCost for Namespace Costs

Source: https://opencost.io/docs/installation/helm

Use the `kubectl cost` command to query cost data for a specific namespace, including CPU, memory, and PV usage, and efficiency metrics. This is useful when OpenCost reports zero values for a namespace, and you need to investigate usage over a specific window.

```bash
kubectl cost --service-port 9003 --service-name opencost --kubecost-namespace opencost --allocation-path /allocation/compute \
    namespace \
    --historical \
    --window 1d \
    --show-cpu \
    --show-memory \
    --show-pv \
    --show-efficiency=true  


| CLUSTER | NAMESPACE     | CPU      | CPU EFF. | MEMORY   | MEMORY EFF. | PV       | TOTAL COST (ALL) | COST EFFICIENCY |
|---------|---------------|----------|----------|----------|-------------|----------|------------------|-----------------|
| dev  | kube-system   | 0.138740 | 0.001965 | 0.023890 | 0.386018    | 0.000000 | 0.162630         | 0.058381        |
|         | monitoring           | 0.000000 | 0.000000 | 0.000000 | 0.000000    | 0.000000 |         0.000000 |        0.000000 |
```

--------------------------------

### GCP Managed Prometheus Error Example

Source: https://opencost.io/docs/configuration/gcp

Illustrates a common error message encountered when using GCP Managed Prometheus with OpenCost due to label relabeling, which disrupts PromQL queries.

```text
ERR CostDataRange: Request Error: Prometheus communication error: 422 (Unprocessable Entity) Headers: { Content-Type: [ application/json; charset=UTF-8 ], Server: [ ESF ], Vary: [ Origin, X-Origin, Referer ], X-Frame-Options: [ SAMEORIGIN ], Cache-Control: [ private ], X-Content-Type-Options: [ nosniff ], X-Xss-Protection: [ 0 ], Date: [ Thu, 28 Sep 2023 10:33:58 GMT ] }, Body: {"status":"error","errorType":"execution","error":"found duplicate series for the match group {namespace=\"redacted\", persistentvolumeclaim=\"redacted\"} on the left hand-side of the operation: [{namespace=\"redacted\", persistentvolumeclaim=\"redacted\", storageclass=\"standard\", volumename=\"redacted\"}, {namespace=\"redacted\", persistentvolumeclaim=\"redacted\", storageclass=\"standard\", volumename=\"redacted\"}];many-to-many matching not allowed: matching labels must be unique on one side"} Query: avg(avg(kube_persistentvolumeclaim_info{volumename != "", }) by (persistentvolumeclaim, storageclass, namespace, volumename, cluster_id, kubernetes_node)  
	*  
	on (persistentvolumeclaim, namespace, cluster_id, kubernetes_node) group_right(storageclass, volumename)  
	sum(kube_persistentvolumeclaim_resource_requests_storage_bytes{}) by (persistentvolumeclaim, namespace, cluster_id, kubernetes_node, kubernetes_name)) by (persistentvolumeclaim, storageclass, namespace, cluster_id, volumename, kubernetes_node)  
```

--------------------------------

### Calculate Cost by Namespace

Source: https://opencost.io/docs/integrations/metrics

Calculates the combined CPU and memory cost for each namespace. It joins container allocation data with node hourly costs.

```PromQL
sum by (namespace) (container_cpu_allocation * on (node) group_left node_cpu_hourly_cost + container_memory_allocation_bytes * on (node) group_left node_ram_hourly_cost / (1024 * 1024 * 1024))
```

--------------------------------

### Calculate Hourly Cost of Load Balancers by Namespace

Source: https://opencost.io/docs/integrations/prometheus

This query calculates the total hourly cost of all load balancers, broken down by namespace.

```promql
sum(kubecost_load_balancer_cost) by (namespace)
```