SkillAgentSearch skills...

compute-on-demand-reservations

Inspects, verifies, and manages Google Compute Engine (GCE) On-Demand reservations and analyzes consumed versus available reserved capacity

Install / Use

npx skills add google/skills --skill compute-on-demand-reservations

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

98/100

Category

Automation

Supported Platforms

Universal

Tags

Our assessment of compute-on-demand-reservations

compute-on-demand-reservations scores 98/100 on our quality scale, 122nd of 2,790 Automation skills we index (top 5%).

Its SKILL.md is 15 KB long, well organised into 16 sections with 5 code examples: a thorough specification that gives an agent plenty to work with.

With 20,340 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
18/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so compute-on-demand-reservations is actively maintained.
  • It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands (1 minor note below). An AI review of the same text found nothing harmful.

  • noteInstalls by piping a downloaded script into a shellline 39
    … host installation commands such as `apt-get` or `curl | bash` without explicit user approval; direct the user to the installation guide ins…

AI review by kimi-k2.7-code on 2026-11-15. Automated pattern scan on 2026-11-15. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

compute-on-demand-reservations compared with similar skills

All 4 of these similar skills score higher than compute-on-demand-reservations; compare them before choosing.

SkillScoreStarsUpdatedFormat
compute-on-demand-reservations (this skill)by google9820.3k54d agoSKILL.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10039.7k7d agoCLAUDE.md
Scraplingby D4Vinci100103.6k2d agoMCP Server

Frequently asked questions

How do I install compute-on-demand-reservations?
Run npx skills add google/skills --skill compute-on-demand-reservations. The install tabs above show the steps for each supported agent.
Which AI agents does compute-on-demand-reservations work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is compute-on-demand-reservations safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands (1 minor note below). An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is compute-on-demand-reservations still maintained?
The repository was last updated about 2 months ago, so compute-on-demand-reservations is actively maintained.

name: compute-on-demand-reservations metadata: version: "1.0.1" category: Compute description: >- Inspects, verifies, and manages Google Compute Engine (GCE) On-Demand reservations and analyzes consumed versus available reserved capacity. Use when checking active reservation capacity, determining whether reserved VMs are available or exhausted, verifying reservation targeting (automatic versus specific reservation), or sharing reservations across projects. Don't use for Spot capacity advice (use gcloud compute advice capacity --provisioning-model=SPOT) or future calendar bookings (use compute-future-reservations).

Compute Engine On-Demand Reservations

The compute-on-demand-reservations skill inspects and manages active Google Compute Engine (GCE) On-Demand reservations. It determines whether guaranteed capacity is available, calculates consumption, verifies instance targeting policies, and audits cross-project sharing.

Usage Attribution

MUST READ: Before executing any gcloud, REST API, or MCP command, you MUST read and follow the instructions in Usage Attribution.


Prerequisites, IAM & Billing

Before querying or managing On-Demand reservations, ensure the environment meets these requirements:

  1. Project & Region Configuration: Prefer passing --project={project_id} and --zone={zone} directly on each command to avoid overwriting global workstation state, or obtain explicit user confirmation before setting defaults (e.g., us-central1 / us-central1-a):
    gcloud config set project {project_id}
    gcloud config set compute/region {region}
    gcloud config set compute/zone {zone}
    
  2. Billing & API Enablement: Ensure the project has an active billing account attached and the Compute Engine API is enabled:
    gcloud services enable compute.googleapis.com --project={project_id}
    
  3. Cloud SDK & Authentication: Ensure the Google Cloud CLI is installed (never execute unprompted host installation commands such as apt-get or curl | bash without explicit user approval; direct the user to the installation guide instead), then authenticate via gcloud auth login (for interactive CLI), gcloud auth application-default login (for SDKs), or GOOGLE_APPLICATION_CREDENTIALS (for service accounts).
  4. IAM Permissions:
    • Read-Only Inspection (list, describe): Grant roles/compute.viewer (or custom role with compute.reservations.list and compute.reservations.get).
    • Reservation Lifecycle (create, update, delete): Grant roles/compute.admin (or custom role with compute.reservations.create, compute.reservations.resize, compute.reservations.update, and compute.reservations.delete).
    • Consuming Reservations (instances create): Grant roles/compute.instanceAdmin.v1 on the project launching VMs (and on both the host/owner project and the consumer project when consuming a shared reservation).
  5. Quota & Organization Policy: Creating an On-Demand reservation immediately consumes regional CPU, GPU, or Local SSD quota. For shared reservations, Compute Engine deducts regional quota in both the host project (at reservation creation) and the consumer project (when VMs launch), and requires the host project to be allowlisted in organization policy constraints/compute.sharedReservationsOwnerProjects.
  6. Billing & Pricing Warning: On-Demand reservations are billed immediately upon creation at the full On-Demand VM rate whether or not VMs are running and consuming the reservation. Review Compute Engine Pricing, Available Regions and Zones, and Google Cloud Locations (strip .md.txt suffixes when presenting documentation URLs to human users) before provisioning.

Command Syntax & Reference

1. List Reservations in a Project / Zone

gcloud compute reservations list \
  --project={project_id} \
  [--filter="zone:({zone})"] \
  [--format="table(name,zone.basename(),specificReservation.instanceProperties.machineType.basename(),specificReservation.assuredCount,specificReservation.inUseCount,specificReservation.count,specificReservationRequired,shareSettings.shareType,status)"]

2. Inspect Reservation Details & Capacity Metrics

gcloud compute reservations describe {reservation_name} \
  --zone={zone} \
  --project={project_id}

(Note: Dense accelerator reservations backed by aggregateReservation leave specificReservation.* columns blank in list and expose aggregateReservation.totalResources and aggregateReservation.inUseResources via describe.)

3. Create a New On-Demand Reservation

[!IMPORTANT] Creating a reservation immediately incurs billing charges. Always obtain explicit human approval before executing gcloud compute reservations create.

gcloud compute reservations create {reservation_name} \
  --project={project_id} \
  --zone={zone} \
  --vm-count={vm_count} \
  (--machine-type={machine_type} | --source-instance-template={template_name}) \
  [--min-cpu-platform={min_cpu_platform}] \
  [--accelerator=count={gpu_count},type={gpu_type}] \
  [--local-ssd=interface={nvme|scsi}] \
  [--require-specific-reservation] \
  [--share-setting=projects --share-with={consumer_project_ids}]  # up to 100 consumer projects in the same org (excluding the host project)

4. Update or Resize an Existing Reservation

Resizing capacity (--vm-count) and modifying shared consumer projects are mutable in place after obtaining explicit human approval (--share-with, --add-share-with, and --remove-share-with accept up to 100 consumer project IDs or project numbers in the same organization excluding the host project itself). Hardware attributes (machineType, minCpuPlatform, accelerator, localSsd, zone, and specificReservationRequired) are immutable after creation and require recreating the reservation.

gcloud compute reservations update {reservation_name} \
  --project={project_id} \
  --zone={zone} \
  [--vm-count={new_vm_count}] \
  [--add-share-with={project_ids_or_numbers} | --remove-share-with={project_ids_or_numbers}]

5. Delete an Unused On-Demand Reservation (Resource Teardown)

To stop ongoing billing for an unused On-Demand reservation, delete it after obtaining explicit human approval (note: deletion fails if the reservation is attached to a resource-based Committed Use Discount where commitment is set—which must be swapped via gcloud beta compute commitments update-reservations—or if a targeted reservation with specificReservationRequired: true still has inUseCount > 0; the command also prompts interactively unless --quiet is passed):

gcloud compute reservations delete {reservation_name} \
  --zone={zone} \
  --project={project_id}

Capacity Utilization Analysis

When inspecting reservation output, verify that the reservation status is READY or UPDATING (exclude reservations in CREATING or DELETING states) and calculate available capacity using the following fields:

  • status: Must be READY or UPDATING before instances can consume reserved capacity. While a reservation is UPDATING (for example, during a capacity resize or share-setting modification), its already provisioned capacity remains consumable up to specificReservation.assuredCount. Only CREATING and DELETING states block consumption.
  • specificReservation.assuredCount: The number of reserved VM instances currently provisioned and physically backed by Compute Engine hardware. Note that assuredCount can be less than specificReservation.count while a reservation is actively upsizing or if a physical host failure degrades the reservation (healthInfo.healthStatus: DEGRADED).
  • specificReservation.count: The total requested target number of VM instances in this reservation block.
  • specificReservation.inUseCount: The number of reserved instances currently consumed by running VMs.
  • Available Reserved Capacity:
    Available Capacity = specificReservation.assuredCount - specificReservation.inUseCount
    

Health & Consumption Thresholds

  • Available (> 0): Provisioned reserved capacity is immediately available. Workloads can launch with 100% provisioning assurance.
  • Exhausted (inUseCount >= assuredCount): Provisioned reserved capacity is fully consumed. New instances matching this specification fall back to unreserved on-demand capacity (if allowed) or fail to launch.

Reservation Targeting Policies

Reservations operate under two distinct consumption modes defined by specificReservationRequired:

| Setting | Consumption Mode | Matching Behavior | | :--- | :--- | :--- | | specificReservationRequired: false | Automatic (ANY_RESERVATION) | Any newly created STANDARD VM whose properties identically match all reserved instanceProperties automatically consumes this reservation. | | specificReservationRequired: true | Targeted (SPECIFIC_RESERVATION) | VMs do not consume this capacity unless they match all reserved instanceProperties and explicitly specify --reservation-affinity=specific --reservation={reservation_name}. |

Exact Hardware & Property Matching Requirement

For a VM to consume a reservation (under either ANY_RESERVATION or SPECIFIC_RESERVATION), every property below must match the reservation's specificReservation.instanceProperties 100% identically:

  • Project and zone: Same project for LOCAL reservations, or an authorized consumer project listed in shareSettings.projectMap, in the exact same zone.
  • machineType: Exact machine type shape.
  • minCpuPlatform: Must match verbatim. If the reservation was created without an explicit CPU platform ("Automatic"), passing --min-cpu-platform on the VM does not match (and vice versa).
  • guestAccelerators: Exact GPU acceleratorType and acceleratorCount (if any).
  • localSsds: Exact Local SSD partition count and exact storage interface (NVME versus SCSI, if any).
  • Placement policies: Exact compact placement resourcePolicies and locationHint (if present on the reservation).
  • provisioningModel: Must be STANDARD (SPOT VMs never consume On-Demand reservations).

[!WARNING] Silent Double-Billing Trap: Under ANY_RESERVATION (--reservation-affinity=any, the default), if a newly created VM matches zone and machineType but differs on even a single property (such as NVME vs. SCSI Local SSD interface or minCpuPlatform), Compute Engine silently skips the reservation, launches an unreserved On-Demand VM, and bills for both the idle reservation and the new VM. Creating both the reservation and VMs from the same --source-instance-template prevents property drift.

VM Provisioning Best Practices

When provisioning VMs, recommend private networking (--no-address paired with IAP TCP forwarding) and a custom least-privilege service account (--service-account):

  • To consume a targeted reservation (specificReservationRequired: true) during instance creation (note: passing --reservation-affinity=specific against a reservation with specificReservationRequired: false is rejected by Compute Engine):
    gcloud compute instances create {vm_name} \
      --project={project_id} \
      --zone={zone} \
      --machine-type={machine_type} \
      --reservation-affinity=specific \
      --reservation={reservation_name} \
      [--no-address] \
      [--service-account={service_account_email}]
    
  • To prevent an instance from consuming any reservation:
    gcloud compute instances create {vm_name} \
      --project={project_id} \
      --zone={zone
    

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars20.3k
CategoryAutomation
Updated1mo ago
Forks1.7k

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions