lspot.py

README.md

list spot

a simple utility to quickly identify the cheapest spot location for an instance type

examples

❯ AWS_PROFILE=redbeard python3.11 lspot.py --help
usage: lspot.py [-h] [--json] [--table] [-v] [-1] [-r REGION] instance_type

Check AWS EC2 spot prices for a given instance type.

positional arguments:
  instance_type         The instance type to check spot prices for (e.g. f1.2xlarge, vt1.3xlarge, inf2.xlarge, p3.8xlarge)

options:
  -h, --help            show this help message and exit
  --json                Output in JSON format.
  --table               Output in table format (default).
  -v, --verbose         Enable verbose output.
  -1, --one             Output the single lowest cost availability zone.
  -r REGION, --region REGION
                        Specify regions to check (can be used multiple times).
❯ AWS_PROFILE=redbeard python3.11 lspot.py p3.8xlarge --table
        Region       A       B       C  MinSpotPrice  MinSpotPriceAZ
  ca-central-1     N/A  2.6116     N/A        2.6116   ca-central-1b
ap-southeast-2  3.0621     N/A     N/A        3.0621 ap-southeast-2a
  eu-central-1  3.2041  4.0255     N/A        3.2041   eu-central-1a
     us-east-2  3.6988  4.1684     N/A        3.6988      us-east-2a
ap-northeast-1     N/A  5.2565  3.8038        3.8038 ap-northeast-1c
ap-northeast-2  3.9893     N/A  4.6567        3.9893 ap-northeast-2a
     us-west-2  4.0283  4.2234  4.1895        4.0283      us-west-2a
     eu-west-1     N/A  5.2513  4.7759        4.7759      eu-west-1c
ap-southeast-1  5.1623  4.9426     N/A        4.9426 ap-southeast-1b
     eu-west-2  5.0261  5.5118     N/A        5.0261      eu-west-2a
     us-east-1  5.5073  6.1285  5.6257        5.5073      us-east-1a
❯ AWS_PROFILE=redbeard python3.11 lspot.py inf2.xlarge --table
        Region       A       B       C  MinSpotPrice  MinSpotPriceAZ
     us-east-2   0.106  0.0908  0.0858        0.0858      us-east-2c
    eu-north-1  0.1037  0.0983     N/A        0.0983     eu-north-1b
     us-west-2  0.1392  0.1399  0.1075        0.1075      us-west-2c
ap-southeast-2  0.1164  0.1162     N/A        0.1162 ap-southeast-2b
     eu-west-3     N/A  0.1323  0.1229        0.1229      eu-west-3c
     sa-east-1     N/A     N/A  0.1289        0.1289      sa-east-1c
  eu-central-1  0.1814  0.1438     N/A        0.1438   eu-central-1b
     eu-west-2  0.2215     N/A     N/A        0.2215      eu-west-2a
ap-southeast-1  0.2597     N/A  0.3101        0.2597 ap-southeast-1a
    ap-south-1  0.3125  0.3726     N/A        0.3125     ap-south-1a
     eu-west-1  0.3284  0.3147     N/A        0.3147      eu-west-1b
     us-east-1  0.4026     N/A  0.3401        0.3258      us-east-1d
ap-northeast-1     N/A  0.3425  0.3282        0.3282 ap-northeast-1c
❯ AWS_PROFILE=redbeard python3.11 lspot.py  -r us-east-2 -r us-west-2 inf2.8xlarge
   Region      A      B      C  MinSpotPrice MinSpotPriceAZ
us-west-2 0.5688 0.6326 0.6060        0.4509     us-west-2d
us-east-2 0.6603 0.5422 0.6003        0.5422     us-east-2b
❯ AWS_PROFILE=redbeard python3.11 lspot.py  -r us-east-2 -r us-west-2 inf2.xlarge
   Region      A      B      C  MinSpotPrice MinSpotPriceAZ
us-east-2 0.1060 0.0908 0.0858        0.0858     us-east-2c
us-west-2 0.1392 0.1399 0.1075        0.1075     us-west-2c
❯ AWS_PROFILE=redbeard python3.11 lspot.py  -r us-east-2 -r us-west-2 inf2.xlarge -1
us-east-2c

lspot.py

import boto3
import argparse
import pandas as pd
import json
import sys
from datetime import datetime, timedelta


def logger(message, verbose):
    """
    Logs a message to stderr if verbose is True.

    Args:
        message (str): The message to log.
        verbose (bool): If True, the message is logged to stderr.
    """
    if verbose:
        sys.stderr.write(f"{message}\n")


def get_spot_prices(instance_type, regions, verbose):
    """
    Fetches the spot prices for a given instance type across specified regions.

    Args:
        instance_type (str): The type of EC2 instance to check spot prices for.
        regions (list): A list of region names to check.
        verbose (bool): If True, logs additional information to stderr.

    Returns:
        list: A list of dictionaries containing spot price information for each region.
    """
    spot_prices = []
    end_time = datetime.utcnow()
    start_time = end_time - timedelta(days=1)

    for region in regions:
        regional_client = boto3.client("ec2", region_name=region)
        logger(f"Fetching availability zones for region {region}...", verbose)
        az_response = regional_client.describe_availability_zones()
        azs = [az["ZoneName"] for az in az_response["AvailabilityZones"]]

        logger(f"Fetching spot price history for region {region}...", verbose)
        prices = regional_client.describe_spot_price_history(
            InstanceTypes=[instance_type],
            ProductDescriptions=["Linux/UNIX"],
            StartTime=start_time,
            EndTime=end_time,
        )

        if prices["SpotPriceHistory"]:
            az_prices = {az: "N/A" for az in azs}
            for price in prices["SpotPriceHistory"]:
                az = price["AvailabilityZone"]
                spot_price = float(price["SpotPrice"])
                if az in az_prices:
                    if az_prices[az] == "N/A" or spot_price < az_prices[az]:
                        az_prices[az] = spot_price

            min_spot_price = min(
                az_prices.values(), key=lambda x: x if x != "N/A" else float("inf")
            )
            min_az = next(
                (az for az, price in az_prices.items() if price == min_spot_price),
                "N/A",
            )

            spot_prices.append(
                {
                    "Region": region,
                    "A": az_prices.get(f"{region}a", "N/A"),
                    "B": az_prices.get(f"{region}b", "N/A"),
                    "C": az_prices.get(f"{region}c", "N/A"),
                    "MinSpotPrice": min_spot_price,
                    "MinSpotPriceAZ": min_az,
                }
            )

    return spot_prices


def output_table(spot_prices):
    """
    Outputs the spot prices in a table format.

    Args:
        spot_prices (list): A list of dictionaries containing spot price information.
    """
    df = pd.DataFrame(spot_prices)
    df = df.sort_values(
        by="MinSpotPrice", ascending=True
    )  # Sort by MinSpotPrice in ascending order
    print(df.to_string(index=False))


def output_json(spot_prices):
    """
    Outputs the spot prices in JSON format.

    Args:
        spot_prices (list): A list of dictionaries containing spot price information.
    """
    sorted_prices = sorted(spot_prices, key=lambda x: x["MinSpotPrice"])
    print(json.dumps(sorted_prices, indent=4))


def output_single_lowest(spot_prices, verbose=False):
    """
    Outputs the single lowest cost availability zone.

    Args:
        spot_prices (list): A list of dictionaries containing spot price information.
        verbose (bool): If True, logs additional information to stderr.
    """
    min_price_entry = min(spot_prices, key=lambda x: x["MinSpotPrice"])
    logger(
        f"Region: {min_price_entry['Region']}, AZ: {min_price_entry['MinSpotPriceAZ']}, Price: {min_price_entry['MinSpotPrice']}",
        verbose,
    )
    print(f"{min_price_entry['MinSpotPriceAZ']}")


def main():
    """
    Main function to parse arguments and fetch spot prices.
    """
    parser = argparse.ArgumentParser(
        description="Check AWS EC2 spot prices for a given instance type."
    )
    parser.add_argument(
        "instance_type",
        type=str,
        help="The instance type to check spot prices for (e.g. f1.2xlarge, vt1.3xlarge, inf2.xlarge, p3.8xlarge)",
    )
    parser.add_argument("--json", action="store_true", help="Output in JSON format.")
    parser.add_argument(
        "--table", action="store_true", help="Output in table format (default)."
    )
    parser.add_argument(
        "-v", "--verbose", action="store_true", help="Enable verbose output."
    )
    parser.add_argument(
        "-1",
        "--one",
        action="store_true",
        help="Output the single lowest cost availability zone.",
    )
    parser.add_argument(
        "-r",
        "--region",
        action="append",
        help="Specify regions to check (can be used multiple times).",
    )

    args = parser.parse_args()

    if args.region:
        regions = args.region
    else:
        client = boto3.client("ec2", region_name="us-east-1")
        logger("Fetching regions...", args.verbose)
        response = client.describe_regions()
        regions = [region["RegionName"] for region in response["Regions"]]

    spot_prices = get_spot_prices(args.instance_type, regions, args.verbose)

    if args.one:
        output_single_lowest(spot_prices, args.verbose)
    elif args.json:
        output_json(spot_prices)
    else:
        output_table(spot_prices)


if __name__ == "__main__":
    main()