Resource Discovery

Emulates the cross-service inventory APIs — the "list everything I have, filtered by service, type, region, or tag" layer that Resource Explorer, Resource Graph, and Cloud Asset Inventory provide. An engine walks your emulated compute, networking, storage, database, serverless, Databricks, Kubernetes, and relational-database resources and answers those queries over normalized, cross-cloud records.

Reach for it in tests when your code enumerates resources, reconciles inventory, or drives tag-based automation — so you can assert on what's discoverable without a real account. Every provider auto-wires a ResourceDiscovery engine over its core drivers, so anything you create through those services is immediately discoverable, with no separate registration step.

Query with the real SDK#

Wire the engine into the server alongside your other drivers, then point the real Resource Explorer client at it — this is the path that exercises the actual discovery API and its query-string filters:

import (
    "github.com/aws/aws-sdk-go-v2/service/resourceexplorer2"
    "github.com/stackshy/cloudemu/v2"
    awsserver "github.com/stackshy/cloudemu/v2/server/aws"
)

cloud := cloudemu.NewAWS()
ts := httptest.NewServer(awsserver.New(awsserver.Drivers{
    EC2: cloud.EC2, VPC: cloud.VPC, S3: cloud.S3,
    ResourceDiscovery: cloud.ResourceDiscovery,
    AccountID:         "123456789012",
    Region:            "us-east-1",
}))

client := resourceexplorer2.NewFromConfig(cfg, func(o *resourceexplorer2.Options) {
    o.BaseEndpoint = aws.String(ts.URL)
})

client.Search(ctx, &resourceexplorer2.SearchInput{
    QueryString: aws.String("service:s3 tag.env:prod"),
})

Wire the engine into azureserver.Drivers{ResourceDiscovery: …, SubscriptionID: …} or gcpserver.Drivers{ResourceDiscovery: …, ProjectID: …} for the Azure and GCP equivalents.

Query with the Portable Go API#

When you don't need the SDK round-trip, query the engine directly — ListAll returns everything, List applies structured filters, and GetTagKeys surfaces the tag namespace for tag-driven tests:

import "github.com/stackshy/cloudemu/v2/services/resourcediscovery"

all, _ := aws.ResourceDiscovery.ListAll(ctx)

results, _ := aws.ResourceDiscovery.List(ctx, resourcediscovery.Query{
    Services: []string{"compute"},
    Type:     "Instance",
    Region:   "us-east-1",
    Tags:     map[string]string{"env": "prod"},
})

keys, _ := aws.ResourceDiscovery.GetTagKeys(ctx)

What it inventories#

The engine reads live state from the service drivers and emits normalized, cross-cloud resource records:

Kubernetes clusters and their node groups are surfaced through a KubernetesClusters discovery adapter each provider wires over its cluster mock. Relational databases follow the same pattern via a RelationalDatabases adapter — AWS RDS/Aurora instances, clusters, and snapshots surface through Resource Explorer 2 (filter service:rds); GCP Cloud SQL and Azure SQL discovery are not yet wired.

Behavior & fidelity#

Each provider's filter dialect:

• AWS — service:, tag.<key>:<value>, and region: across Resource Explorer 2 and the Resource Groups Tagging API.
• Azure — a KQL subset over the Resources table: where type == / in~ (…), where location ==, where tags['k'] ==, and | limit / | take.
• GCP — Cloud Asset Inventory filters service:, assetType:, location:, and labels.<k>:<v>.

Cost-relevant fields projected on each Azure type:

Values are seeded through the portable driver configs and optional enrichment capabilities — e.g. VolumeConfig.IOPS/Throughput/Tier, InstanceConfig.OSType/Priority/LicenseType/Zones, the AKS Tier/ScaleSetPriority inputs, and BucketAttributes / TableAttributes.

SDK-compat — Live#

Real Resource Explorer 2, Resource Graph, and Cloud Asset Inventory clients drive it end-to-end; the same queries run through the Portable Go API above.

See SDK-Compat for the full per-operation list.