_vultr

sc_crawler.vendors._vultr

Functions:

Name	Description
inventory_regions	List all regions from Vultr API.
inventory_zones	List all regions as availability zones.
inventory_servers	List all servers from Vultr API.
inventory_traffic_prices	Public network traffic rates (flat worldwide).
inventory_ipv4_prices	Reserved / additional public IPv4 (flat worldwide).

inventory_regions

inventory_regions(vendor)

List all regions from Vultr API.

Source code in sc_crawler/vendors/_vultr.py

def inventory_regions(vendor):
    """List all regions from Vultr API."""
    items = []
    regions = _get_regions()
    for region in regions:
        with sentry_capture_or_raise(vendor=vendor):
            location = _REGION_LOCATIONS.get(region["id"], {})
            items.append(
                {
                    "vendor_id": vendor.vendor_id,
                    "region_id": region["id"],
                    "name": region["city"],
                    "api_reference": region["id"],
                    "display_name": f"{region['city']} ({region['country']})",
                    "aliases": [],
                    "country_id": region["country"],
                    "state": location.get("state"),
                    "city": region["city"],
                    "address_line": None,
                    "zip_code": None,
                    "lon": location.get("lon"),
                    "lat": location.get("lat"),
                    "founding_year": location.get("founding_year"),
                    "green_energy": location.get("green_energy"),
                }
            )
    return items

inventory_zones

inventory_zones(vendor)

List all regions as availability zones.

There is no concept of having multiple availability zones within a region (virtual datacenter) at Vultr, so creating 1-1 dummy Zones reusing the Region id and name.

Source code in sc_crawler/vendors/_vultr.py

def inventory_zones(vendor):
    """List all regions as availability zones.

    There is no concept of having multiple availability zones within
    a region (virtual datacenter) at Vultr, so creating 1-1
    dummy Zones reusing the Region id and name.

    """
    items = []
    for region in vendor.regions:
        items.append(
            {
                "vendor_id": vendor.vendor_id,
                "region_id": region.region_id,
                "zone_id": region.region_id,
                "name": region.name,
                "api_reference": region.name,
                "display_name": region.name,
            }
        )
    return items

inventory_servers

inventory_servers(vendor)

List all servers from Vultr API.

Source code in sc_crawler/vendors/_vultr.py

def inventory_servers(vendor):
    """List all servers from Vultr API."""
    plans = _get_plans()
    plans_metal = _get_plans_metal()

    items = []
    for server in plans + plans_metal:
        # exclude limited plans not generally available without scale
        if server["id"] == "vc2-1c-0.5gb-free":
            continue

        # CPU
        cpu_model_raw = server.get("cpu_model", "")
        cpu_manufacturer = server.get("cpu_vendor") or server.get("cpu_manufacturer")
        cpu_family = _extract_cpu_family(cpu_model_raw)
        cpu_model = _standardize_cpu_model(cpu_model_raw)
        vcpus = server.get("vcpu_count")
        cpu_count = server.get("cpu_count")
        cpu_threads = server.get("cpu_threads", 0)
        cpu_allocation = CpuAllocation.SHARED if vcpus else CpuAllocation.DEDICATED
        cpu_architecture = (
            CpuArchitecture.ARM64 if cpu_family == "Grace" else CpuArchitecture.X86_64
        )
        cpu_speed_mhz = server.get("cpu_mhz")
        cpu_speed_ghz = cpu_speed_mhz / 1000 if cpu_speed_mhz else None

        # GPU
        gpu_brand = server.get("gpu_brand", "")
        gpu_type = server.get("gpu_type")
        gpu_manufacturer_from_type = gpu_type.split("_")[0] if gpu_type else ""
        gpu_manufacturer = _extract_manufacturer(gpu_brand) or _extract_manufacturer(
            gpu_manufacturer_from_type
        )
        gpu_profile = _GPU_TYPES.get(gpu_type, {})
        gpu_vram_gb = gpu_profile.get("vram_gb")
        gpu_family = gpu_profile.get("family")
        gpu_vram_total_gb = server.get("gpu_vram_gb", 0)
        gpu_memory_min = (
            int(min(gpu_vram_gb, gpu_vram_total_gb) * _MIB_PER_GIB)
            if gpu_vram_gb and gpu_vram_total_gb
            else None
        )
        gpu_count = round(gpu_vram_total_gb / gpu_vram_gb, 4) if gpu_vram_gb else 0
        gpu_model = " ".join(gpu_type.split("_")[1:]) if gpu_type else None

        # Storage
        storage_size_per_disk = server.get("disk")
        storage_type = _storage_type_from_plan(server)
        storage_size = storage_size_per_disk * server.get("disk_count", 1)

        items.append(
            {
                "vendor_id": vendor.vendor_id,
                "server_id": server["id"],
                "name": server["id"],
                "api_reference": server["id"],
                "display_name": server["id"],
                "description": None,
                "family": _PLAN_TYPES.get(server["type"]),
                "vcpus": vcpus or cpu_threads,
                "hypervisor": None,
                "cpu_allocation": cpu_allocation,
                "cpu_cores": vcpus or cpu_count,
                "cpu_speed": cpu_speed_ghz,
                "cpu_architecture": cpu_architecture,
                "cpu_manufacturer": cpu_manufacturer,
                "cpu_family": cpu_family,
                "cpu_model": cpu_model,
                "cpu_l1d_cache": None,
                "cpu_l1d_cache_total": None,
                "cpu_l1i_cache": None,
                "cpu_l1i_cache_total": None,
                "cpu_l2_cache": None,
                "cpu_l2_cache_total": None,
                "cpu_l3_cache": None,
                "cpu_l3_cache_total": None,
                "cpu_flags": [],
                "cpus": [],
                "memory_amount": server["ram"],
                "memory_generation": None,
                "memory_speed": None,
                "memory_ecc": None,
                "gpu_count": gpu_count,
                "gpu_memory_min": gpu_memory_min,
                "gpu_memory_total": (
                    int(gpu_vram_total_gb * _MIB_PER_GIB) if gpu_vram_total_gb else None
                ),
                "gpu_manufacturer": gpu_manufacturer,
                "gpu_family": gpu_family,
                "gpu_model": gpu_model,
                "gpus": [],
                "storage_size": storage_size,
                "storage_type": storage_type,
                "storages": [],
                "network_speed_baseline": None,
                "network_speed_max": None,
                "network_storage_speed_baseline": None,
                "network_storage_speed_max": None,
                "inbound_traffic": 0,
                "outbound_traffic": server.get("bandwidth", 0),
                # the smallest plan is IPv6-only
                "ipv4": 0 if server["id"] == "vc2-1c-0.5gb-v6" else 1,
            }
        )
    return items

inventory_traffic_prices

inventory_traffic_prices(vendor)

Public network traffic rates (flat worldwide).

Ingress is free. Outbound overage beyond pooled plan + account quota is billed per GB; included allowances are on each server plan bandwidth field.

Source: https://docs.vultr.com/support/platform/billing/what-is-the-bandwidth-overage-rate

Source code in sc_crawler/vendors/_vultr.py

def inventory_traffic_prices(vendor):
    """Public network traffic rates (flat worldwide).

    Ingress is free. Outbound overage beyond pooled plan + account quota is
    billed per GB; included allowances are on each server plan ``bandwidth`` field.

    Source: <https://docs.vultr.com/support/platform/billing/what-is-the-bandwidth-overage-rate>
    """
    items = []
    regions = _get_regions()
    for region in regions:
        items.append(
            {
                "vendor_id": vendor.vendor_id,
                "region_id": region["id"],
                "price": 0,
                "price_tiered": [],
                "currency": "USD",
                "unit": PriceUnit.GB_MONTH,
                "direction": TrafficDirection.IN,
            }
        )
        items.append(
            {
                "vendor_id": vendor.vendor_id,
                "region_id": region["id"],
                "price": 0.01,
                "price_tiered": [],
                "currency": "USD",
                "unit": PriceUnit.GB_MONTH,
                "direction": TrafficDirection.OUT,
            }
        )
    return items

inventory_ipv4_prices

inventory_ipv4_prices(vendor)

Reserved / additional public IPv4 (flat worldwide).

Primary instance IPv4 is included in compute pricing; this is the published rate for reserved IPs (also used for extra addresses).

Source: https://docs.vultr.com/support/products/network/are-reserved-ips-free

Source code in sc_crawler/vendors/_vultr.py

def inventory_ipv4_prices(vendor):
    """Reserved / additional public IPv4 (flat worldwide).

    Primary instance IPv4 is included in compute pricing; this is the published
    rate for reserved IPs (also used for extra addresses).

    Source: <https://docs.vultr.com/support/products/network/are-reserved-ips-free>
    """
    items = []
    regions = _get_regions()
    for region in regions:
        items.append(
            {
                "vendor_id": vendor.vendor_id,
                "region_id": region["id"],
                "price": 3.0,
                "currency": "USD",
                "unit": PriceUnit.MONTH,
            }
        )
    return items