finops-expert

name	finops-expert
version	1.0.0
description	Expert-level cloud financial operations, cost optimization, and cloud economics
category	professional
tags	["finops","cloud-cost","optimization","cloud-economics","aws-cost"]
allowed-tools	["Read","Write","Edit","Bash(*)"]

FinOps Expert

Expert guidance for cloud financial operations, cost optimization, resource management, and cloud economics.

Core Concepts

FinOps Fundamentals

• Cloud cost visibility
• Usage optimization
• Rate optimization
• Architecture optimization
• Cloud unit economics
• Showback and chargeback

Cost Management

• Reserved Instances (RIs)
• Savings Plans
• Spot instances
• Right-sizing resources
• Idle resource cleanup
• Storage lifecycle policies

FinOps Practices

• Tagging strategies
• Budgets and alerts
• Cost allocation
• Forecasting and planning
• Cross-team collaboration
• Continuous optimization

AWS Cost Analysis

import boto3
from datetime import datetime, timedelta
from typing import Dict, List
import pandas as pd

class AWSCostAnalyzer:
    """Analyze AWS costs using Cost Explorer API"""

    def __init__(self):
        self.ce_client = boto3.client('ce')

    def get_cost_and_usage(self, start_date: str, end_date: str,
                          granularity: str = 'DAILY',
                          metrics: List[str] = None) -> Dict:
        """Get cost and usage data"""
        if metrics is None:
            metrics = ['UnblendedCost', 'UsageQuantity']

        response = self.ce_client.get_cost_and_usage(
            TimePeriod={
                'Start': start_date,
                'End': end_date
            },
            Granularity=granularity,
            Metrics=metrics,
            GroupBy=[
                {'Type': 'DIMENSION', 'Key': 'SERVICE'}
            ]
        )

        return response['ResultsByTime']

    def get_top_services_by_cost(self, days:  = , top_n:  = ) -> pd.DataFrame:
        
        end_date = datetime.now().strftime()
        start_date = (datetime.now() - timedelta(days=days)).strftime()

        results = .get_cost_and_usage(start_date, end_date, )

        service_costs = {}
         result  results:
             group  result[]:
                service = group[][]
                cost = (group[][][])

                 service  service_costs:
                    service_costs[service] += cost
                :
                    service_costs[service] = cost

        df = pd.DataFrame((service_costs.items()),
                         columns=[, ])
         df.nlargest(top_n, )

     () -> :
        
        start_date = datetime.now().strftime()
        end_date = (datetime.now() + timedelta(days=days_ahead)).strftime()

        response = .ce_client.get_cost_forecast(
            TimePeriod={
                : start_date,
                : end_date
            },
            Metric=,
            Granularity=
        )

         {
            : (response[][]),
            : (response[][][])
        }

     () -> []:
        
        response = .ce_client.get_rightsizing_recommendation(
            Service=
        )

        recommendations = []
         rec  response[]:
            recommendations.append({
                : rec[][],
                : rec[][],
                : rec[][][][]
                     rec.get()  ,
                : (rec[][])
                     rec.get()  
            })

         recommendations

 :
    

     ():
        .ec2_client = boto3.client()
        .rds_client = boto3.client()
        .s3_client = boto3.client()

     () -> [, ]:
        
        idle_resources = {
            : [],
            : [],
            : [],
            : []
        }

        
        instances = .ec2_client.describe_instances(
            Filters=[{: , : []}]
        )

         reservation  instances[]:
             instance  reservation[]:
                idle_resources[].append({
                    : instance[],
                    : instance[],
                    : instance[][]
                })

        
        volumes = .ec2_client.describe_volumes(
            Filters=[{: , : []}]
        )

         volume  volumes[]:
            idle_resources[].append({
                : volume[],
                : volume[],
                : volume[]
            })

        
        addresses = .ec2_client.describe_addresses()

         address  addresses[]:
                address:
                idle_resources[].append({
                    : address[],
                    : address[]
                })

         idle_resources

     () -> :
        
        
        on_demand_hourly = ._get_on_demand_price(instance_type)
        ri_hourly = on_demand_hourly *   

        hours_per_year =  * 
        annual_on_demand = on_demand_hourly * hours_per_year * count
        annual_ri = ri_hourly * hours_per_year * count

         {
            : instance_type,
            : count,
            : annual_on_demand,
            : annual_ri,
            : annual_on_demand - annual_ri,
            : ((annual_on_demand - annual_ri) / annual_on_demand) * 
        }

     () -> :
        
        
        prices = {
            : ,
            : ,
            : ,
            : ,
            : 
        }
         prices.get(instance_type, )

Cost Allocation and Tagging

class CostAllocation:
    """Manage cost allocation with tags"""

    def __init__(self):
        self.ec2_client = boto3.client('ec2')
        self.ce_client = boto3.client('ce')

    def define_tagging_strategy(self) -> Dict[str, List[str]]:
        """Define mandatory tags"""
        return {
            'environment': ['prod', 'staging', 'dev'],
            'team': ['engineering', 'data', 'product'],
            'cost_center': ['CC001', 'CC002', 'CC003'],
            'project': ['project-a', 'project-b'],
            'owner': ['email addresses']
        }

    def audit_resource_tags(self, resource_type: str = 'instance') -> List[Dict]:
        """Audit resources for missing tags"""
        mandatory_tags = ['environment', 'team', 'cost_center']
        untagged_resources = []

        if resource_type == 'instance':
            instances = .ec2_client.describe_instances()

             reservation  instances[]:
                 instance  reservation[]:
                    tags = {tag[]: tag[]
                            tag  instance.get(, [])}

                    missing_tags = [tag  tag  mandatory_tags
                                   tag   tags]

                     missing_tags:
                        untagged_resources.append({
                            : instance[],
                            : missing_tags
                        })

         untagged_resources

     () -> pd.DataFrame:
        
        response = .ce_client.get_cost_and_usage(
            TimePeriod={
                : start_date,
                : end_date
            },
            Granularity=,
            Metrics=[],
            GroupBy=[
                {: , : tag_key}
            ]
        )

        costs = []
         result  response[]:
             group  result[]:
                costs.append({
                    : group[][].split()[]
                           group[][]  ,
                    : (group[][][])
                })

         pd.DataFrame(costs)

Budget Management

class BudgetManager:
    """Manage AWS budgets and alerts"""

    def __init__(self):
        self.budgets_client = boto3.client('budgets')
        self.account_id = boto3.client('sts').get_caller_identity()['Account']

    def create_monthly_budget(self, name: str, amount: float,
                             email: str) -> Dict:
        """Create monthly cost budget with alerts"""
        budget = {
            'BudgetName': name,
            'BudgetLimit': {
                'Amount': str(amount),
                'Unit': 'USD'
            },
            'TimeUnit': 'MONTHLY',
            'BudgetType': 'COST'
        }

        # Alert at 80% and 100%
        notifications = [
            {
                'Notification': {
                    'NotificationType': 'ACTUAL',
                    'ComparisonOperator': 'GREATER_THAN',
                    'Threshold': 80,
                    'ThresholdType': 'PERCENTAGE'
                },
                'Subscribers': [{
                    'SubscriptionType': 'EMAIL',
                    'Address': email
                }]
            },
            {
                : {
                    : ,
                    : ,
                    : ,
                    : 
                },
                : [{
                    : ,
                    : email
                }]
            }
        ]

        response = .budgets_client.create_budget(
            AccountId=.account_id,
            Budget=budget,
            NotificationsWithSubscribers=notifications
        )

         response

Best Practices

Cost Visibility

• Implement comprehensive tagging
• Enable Cost Explorer
• Set up cost allocation tags
• Create custom cost reports
• Use dashboards for visualization
• Monitor costs daily

Optimization

• Right-size resources regularly
• Use Reserved Instances/Savings Plans
• Leverage Spot instances for flexible workloads
• Implement auto-scaling
• Clean up idle resources
• Use storage lifecycle policies

Governance

• Set budgets and alerts
• Implement approval workflows
• Regular cost reviews
• Cross-team accountability
• Document cost optimization wins
• Automate cost controls

Anti-Patterns

❌ No tagging strategy ❌ Ignoring rightsizing recommendations ❌ Not using Reserved Instances ❌ No budget alerts ❌ Keeping idle resources ❌ Manual cost tracking ❌ Siloed cost responsibility

Resources

• AWS Cost Explorer: https://aws.amazon.com/aws-cost-management/aws-cost-explorer/
• FinOps Foundation: https://www.finops.org/
• AWS Well-Architected Cost Optimization: https://wa.aws.amazon.com/wat.pillar.costOptimization.en.html
• Boto3 Cost Explorer: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/ce.html