Changelog

This release adds two more AWS services, ships cloudemu's redesigned logo, makes the built-in Kubernetes cluster work smoothly inside Docker, and rewrites the docs so anyone — in any language, not just Go — can see what cloudemu really is: a local cloud you run and point your apps at.

New look

cloudemu has a brand-new logo — a cloud paired with a terminal prompt and the tagline "the cloud, in memory." It's transparent and theme-adaptive, so it looks crisp on both light and dark backgrounds across GitHub, the docs, and pkg.go.dev.

Features

Two more AWS services

Point the real AWS SDK (or the aws CLI) at cloudemu and these respond just like the real thing — only in memory, with no account and no bill.

• GuardDuty (threat detection) — manage detectors, threat-intelligence sets, filters, and findings entirely in memory. Full coverage of all 87 operations, so aws-sdk-go-v2/service/guardduty and the aws guardduty CLI work by only changing the endpoint.
• MSK — Managed Streaming for Apache Kafka — create and manage Kafka clusters, configurations, and connectors. Full coverage of all 59 operations for aws-sdk-go-v2/service/kafka and the aws kafka CLI.

Enhancements

Clearer documentation

• The README now speaks to everyone. It leads with what cloudemu actually is — a runnable local cloud (via Docker or a single binary) that you point any app, in any language, at — rather than a Go-testing-only tool. New copy-paste Docker quickstart, a "three ways to run it" overview, and a proper Contributing & community section for newcomers.

Cleaner internals

• OCI tidy-up. Oracle Cloud (OCI)-only capabilities moved out of the shared service packages, keeping each provider's code self-contained and easier to extend.

Fixes

Kubernetes

• Works inside Docker now. When you run the cloudemu container, its built-in Kubernetes cluster is reachable from your machine with kubectl and client libraries — previously it advertised an address that couldn't be dialed from outside the container.
• `kubectl apply --server-side` for core resources. Server-side apply, "create the object if it doesn't exist yet," and finalizer-aware deletes now work for ConfigMaps, Secrets, Services, and Deployments — so real tools and operators behave the way they would on a genuine cluster.

Technical Details

Features

Point a real aws-sdk-go-v2 / Azure / OCI SDK (or its CLI) at cloudemu and these services respond with full operation parity — atomic creates, typed exceptions, and deep-copied reads throughout.

AWS — Security & Compliance

• KMS — customer keys with real cryptography: AES-256-GCM encrypt/decrypt, RSA/ECC sign & verify, HMAC, data keys, key rotation, aliases, grants, and imported key material.
• ACM — certificate manager issuing genuine self-signed X.509 (RSA-2048/SHA-256), import/export, renewal, revocation, and DNS-validation records.
• WAFv2 — Web ACLs, IP sets, rule groups, and regex pattern sets with LockToken optimistic concurrency and REGIONAL/CLOUDFRONT scoping.
• CloudTrail — trails with logging status, event data stores, channels, dashboards, event/insight selectors, and CloudTrail Lake queries.
• AWS Config — configuration & recording (configuration recorders, delivery channels), Config rules, conformance packs, aggregators, stored queries, and the SelectResourceConfig/SelectAggregateResourceConfig query surface.

AWS — Data, Analytics & Streaming

• Kinesis Data Streams — shards with real MD5 hash-key routing, monotonic sequence numbers, shard iterators, resharding, and enhanced fan-out consumers (incl. SubscribeToShard).
• OpenSearch Service — domains (config, versions), packages, VPC endpoints, data sources, applications, and cross-cluster connections.
• Glue — the Data Catalog (databases, tables, partitions, connections, user-defined functions), crawlers, ETL jobs/triggers/workflows, ML transforms, and the Schema Registry.

AWS — Storage, Email & Orchestration

• EFS — elastic file systems with mount targets, access points, and lifecycle / backup / replication policies.
• SES v2 — email sending with identities, configuration sets, templates, and suppression lists.
• Step Functions — state machines, executions + history, versions/aliases, and activities.

AWS — Networking & Connectivity

• VPC Lattice — 73-operation SDK-compat parity (service networks, services, listeners, target groups, rules).
• Route 53 Resolver — resolver endpoints, rules, and rule associations.

OCI (Oracle Cloud Infrastructure) — new provider

cloudemu gains a third cloud: a new OCI provider foundation (OCIDs, work requests, and the shared wire layer) plus its first three services.

• Identity — users, groups, policies, and compartments.
• Monitoring — metrics and alarms.
• VCN (Virtual Cloud Network) — networks, subnets, route tables, gateways, and security lists.

Standalone emulator & operations

Run cloudemu as a real background service with durable state.

• Lifecycle CLI — start / stop / status / logs / delete the emulator as a daemon.
• State persistence — state survives restarts (snapshot on stop, restore on start).
• Cloud snapshots — save / load / list named state snapshots on demand.
• Init hooks — auto-seed fixtures on boot.
• Topology CLI — check reachability with net can-connect / trace.
• Cost preview — per-SKU, per-region monthly cost estimate.

Resource discovery & capability docs

• Resource discovery (Workstream A) — the resources cloudemu already emulates (relational DB, Kubernetes, load balancers, cache, container registry, queues/notifications, secrets, DNS, IAM, networking sub-types, ML/GenAI, monitoring) now surface through Resource Explorer 2 / Resource Graph / Cloud Asset inventory APIs.
• Generated capability coverage — docs/coverage/ (+ root llms.txt / AGENTS.md) is generated from the driver interfaces via go generate, so the published capability index can't drift from the code.

Enhancements

Repository structure & tooling

• Role-based layout & naming convention — a services/ (drivers) · providers/ · server/ split that keeps each SDK-compat service a self-contained, drop-in package.

Technical Details

Features

AWS VPC networking

• Transit Gateway — connect many VPCs and on-prem networks through a central hub (attachments, route tables, routes, propagation).
• Site-to-Site & Client VPN — customer/virtual-private gateways, VPN connections with static routes, and Client VPN remote-access endpoints with target networks and authorization rules.
• PrivateLink (VPC endpoint services) — publish a service and let other VPCs consume it privately.
• DHCP option sets, managed prefix lists, egress-only internet gateways (IPv6 outbound), and Network Firewall.
• VPC IP Address Manager (IPAM) — plan and hand out your IP space: pools, scopes, allocations, BYOIP/BYOASN, prefix-list resolver, policy, and usage metrics.
• Traffic Mirroring — copy VPC traffic to monitoring appliances (targets, filters, sessions).
• Network Insights — Reachability Analyzer ("can A reach B?") and Network Access Analyzer (access-scope analyses).
• VPC Block Public Access — the account/region control that blocks internet access broadly, with per-VPC/subnet exclusions.

Azure Cosmos DB for PostgreSQL & Databricks

• Cosmos DB for PostgreSQL (Citus) — provision distributed PostgreSQL cluster groups (Microsoft.DBforPostgreSQL/serverGroupsv2) with the Azure SDK/CLI.
• Databricks — full Microsoft.Databricks ARM resource coverage, so a workspace deployment models end to end.

Resource discovery & cost inventory

• Discovered resources now carry VM size/SKU, attached managed disks, and database tier, so inventory and cost views match what a real account would show.
• Azure Resource Graph cost fields — every supported Azure type projects its priceable SKU/tier/capacity through armresourcegraph (VMs & scale sets, disks, SQL databases/managed instances, storage accounts, Cosmos, AKS, App Service plans, …) and survives real-SDK creation end to end, so a Resource Graph cost query returns the same shape as a real subscription.

Enhancements

AWS service operations & tagging

• SQS — get/set queue attributes, purge a queue, and tagging.
• Lambda — versions, aliases, resource-based permissions (AddPermission/GetPolicy/RemovePermission), and tagging.
• Consistent tagging across EC2, SNS, DynamoDB, SQS, SSM, and Lambda.
• More operations to complete provision/teardown flows — ECR login (GetAuthorizationToken), Secrets Manager update + tagging, IAM inline role policies, ElastiCache cluster modify, CloudWatch Logs retention, and extra EC2 lookups (DescribeRegions, DescribeInstanceTypes, …).

Kubernetes data plane

• Completed API-surface parity — the existing in-memory cluster (reachable via any EKS/AKS/GKE kubeconfig) now serves the remaining surface, so kubectl, Helm, and controller-runtime / operator-SDK workloads behave as they would against a real cluster.
• CustomResourceDefinitions — a created CRD is served, discoverable, and Established immediately; deleting it cascade-deletes its custom resources.
• Server-side apply — per-fieldManager ownership in managedFields, 409 conflicts with force takeover, and field removal on re-apply.
• Metrics & autoscaling — kubectl top (metrics.k8s.io) and CPU-utilization-driven HorizontalPodAutoscaler actuation.
• Policy & admission — object-count ResourceQuota, LimitRange defaulting, RBAC SubjectAccessReview, NetworkPolicy evaluation, and opt-in admission webhooks.
• Deterministic controllers — DeploymentReplicaSetPod, DaemonSet, and cron-parsed CronJob scheduling, all driven explicitly (no wall clock).

Fixes

AWS

• Messaging now delivers — messages published to an SNS topic, and events matched by an EventBridge rule, reach subscribed SQS queues (previously dropped).
• Correct not-found errors — EC2 Describe* for a nonexistent ID returns the proper *.NotFound instead of an empty result.
• Truer request/response behavior — DynamoDB applies FilterExpression in Query; S3 honors max-keys/pagination and serves HeadBucket + bucket tagging; CloudWatch now works from the aws CLI.

GCP

• Fidelity fixes across 19 services — a partial update to a Cloud Monitoring alert policy no longer silently disables it; Pub/Sub subscription listing returns your real subscriptions in stable, sorted order; and long-running operations resolve correctly for the Artifact Registry / Eventarc SDK clients.

Technical Details

Features

Managed database services

Nine managed database and data services now work against cloudemu with their real SDKs — including the native child resources a real workload provisions, surfaced in cross-service discovery and priced in the cost catalog:

• AWS Keyspaces (Cassandra) — keyspaces, tables, and user-defined types over the JSON-1.0 wire.
• AWS MemoryDB for Redis/Valkey — clusters, subnet and parameter groups, ACLs, snapshots, and fleet-maintenance operations.
• GCP AlloyDB — clusters, instances, users, databases, and backups.
• GCP Bigtable Admin — instances, clusters, tables (with column families and GC rules), app profiles, backups, and per-resource IAM.
• Azure Managed Instance for Apache Cassandra — clusters and datacenters, deallocate/start, status, and invoke-command.
• Managed SQL — Azure SQL (including Managed Instances), Azure MySQL and PostgreSQL Flexible Server, and GCP Cloud SQL, now with their native child resources: databases, users, firewall rules, elastic pools, and failover groups.

AWS RDS & Bedrock

• RDS reaches full management-plane parity, and now appears in resource discovery with cost and CloudWatch metrics.
• Bedrock is complete across bedrock, bedrockruntime, bedrockagent, and bedrockagentruntime.

AWS ECS

• A new ECS service, so real aws-sdk-go-v2/service/ecs clients work against cloudemu unchanged.
• EC2 managed-resource visibility — Operator.Managed and IncludeManagedResources on DescribeInstances.

Kubernetes

• A shared in-memory API server with a synchronous, deterministic reconcile engine that drives objects to a healthy running state on every write.
• The full cluster lifecycle — create running scale rolling update teardown — across EKS, GKE, and AKS.
• Real kubectl works end to end, not just client-go.
• Clusters and node groups appear in resource discovery.

Standalone server tooling

• Docker image — pull and run the whole emulated cloud as a container.
• Testcontainers-Go module — start cloudemu from a Go test in one line.
• Declarative seed fixtures — preload resources from a fixture file or the /_cloudemu/seed endpoint.
• Reset control plane — /_cloudemu/reset wipes all state between tests for isolation.

S3 object versioning

• Full version history, versionId operations, delete markers, and versioned multipart completion.

Enhancements

Improvements that came out of running real infrastructure provisioners against cloudemu — closing behavior gaps so full provision-and-teardown flows work end to end.

SSM Parameter Store

• GetParametersByPath and DescribeParameters now paginate, so large parameter trees come back page by page, exactly as the real service returns them.
• Requesting a parameter version that doesn't exist now returns the precise ParameterVersionNotFound error instead of a generic "not found".

S3

• ListParts now reports the parts you've actually uploaded to a multipart upload, and rejects part numbers outside the valid 1–10000 range.
• Unsupported operations on S3 sub-resources now return 405 Method Not Allowed, matching real S3.

Azure Table Storage

• $filter queries that use unsupported expressions or partial-key predicates are now rejected with a clear error, instead of quietly returning incorrect results.
• $filter expressions with extra whitespace are now parsed correctly.

Technical Details

Features

Standalone server mode — cloudemu serve

Run cloudemu as a real server and point any SDK, in any language, at it over the network — not just the in-process test double.

• All three providers on stable ports: AWS 4566, Azure 4568 (HTTPS), GCP 4569, plus a shared Kubernetes data-plane
• Self-signed TLS for Azure, request logging, and graceful shutdown
• Prints the endpoints (and writes them as JSON) so an app can target the whole emulated cloud at once
• New DriversFrom / NewFromProvider helpers build a running server from a provider in one line
• Purely additive — the in-process New(Drivers{…}) API is unchanged

Enhancements

DNS fidelity

• Record and zone listing are now deterministic (were random order)
• Zones are scoped to their resource group / project on both list and lookup
• Azure CreateOrUpdate applies the request's tags instead of echoing the old zone
• Long TXT values are split into valid ≤255-byte chunks
• ChangeResourceRecordSets is all-or-nothing — a bad batch leaves the zone untouched
• GCP managed-zone names must be unique within a project

SDK-compat listing & updates

• Logging, event bus, cache, and notification gained scoped listing, CreateOrUpdate-applies-updates, and request-derived Azure ARM ids (no more hardcoded rg-default)

Azure Service Bus namespaces

• Namespaces now keep state: tags persist, listing is scoped to the resource group, and a wrong-group Get/Delete no longer touches another group's namespace

Real-cloud semantics audit

• Typed errors, fake-clock time handling, and map/slice copying at store boundaries brought in line with the real services

Technical Details

Enhancements

Pagination correctness

All three NoSQL drivers paged over a randomized map snapshot with offset tokens, so multi-page Query/Scan duplicated and dropped items. Results now get a stable type-aware ordering (numbers numerically — no more "10" < "9"), the invariant is enforced centrally by pagination.PaginateSorted, and a malformed page token returns InvalidArgument on every driver instead of an empty 200 page that clients read as end-of-results.

DynamoDB key-based continuation

ExclusiveStartKey / LastEvaluatedKey were not implemented — SDK clients could never page past page 1. Continuation now lives in the driver: per-page cost is O(page) instead of O(table), ScanIndexForward:false pages descending, GSI queries order by the index keys and return the real LastEvaluatedKey shape (index + base keys), and a stale or unknown start key is a ValidationException rather than a silent restart that re-serves consumed items.

Conditional writes & document merges

DynamoDB PutItem honors ConditionExpression attribute_exists / attribute_not_exists — including #alias names via ExpressionAttributeNames — with ConditionalCheckFailedException. Firestore :commit enforces currentDocument exists-preconditions (409/404) and honors updateMask on both write paths: masked paths are written or deleted-when-absent, unmentioned fields survive.

Wire fidelity

S3 PutObject returns the ETag header. Azure Put Blob honors x-ms-blob-content-type. GCS multipart uploads parse byte-exact via mime/multipart (trailing -/CRLF bytes are no longer stripped from payloads) and metadata.contentType takes precedence like real GCS. Firestore batchGet returns one JSON array (clients previously decoded only the first document) and runQuery honors structuredQuery.where and limit. Cosmos routes continuation-page queries correctly (application/query+json was previously misrouted to document create 400) and both the query and GET-list paths page via x-ms-max-item-count / x-ms-continuation.

Test coverage

~110 lifecycle suites across 12 cells (storage + database × 3 providers × 2 surfaces): full lifecycles, typed errors, pagination continuation, multipart, TTL under the fake clock, streams/change feeds, GSIs, conditional writes, unicode keys, batch ops. Every fix is locked by a test that fails on pre-fix code.

Technical Details

A major release. cloudemu is now organized by role so the repository stays legible as it grows — service packages live under services/, the cross-cutting wrappers under features/, and shared plumbing under internal/. Because that moves public import paths, the module is now github.com/stackshy/cloudemu/v2. On top of the restructure this release adds five new SDK-compat surfaces — AWS STS, AWS SSM Parameter Store, S3 multipart / tagging / versioning, Azure Queue & Table Storage, and Azure AI — and ships a full CI/CD + security pipeline.

Breaking Changes

• Module path is now `/v2`. Update the dependency and your imports:

``bash go get github.com/stackshy/cloudemu/v2@v2.0.0 ` `go // before import "github.com/stackshy/cloudemu/storage" // after import "github.com/stackshy/cloudemu/v2/services/storage" ``

• Public packages moved by role (import path == directory, so these are the source-visible changes):
• Every emulated service services/<name> (e.g. storage services/storage, compute services/compute, kubernetes services/kubernetes, resourcediscovery services/resourcediscovery, cost services/cost).
• Cross-cutting wrappers features/<name>: chaos, recorder, metrics, ratelimit, inject, topology.
• Shared helpers internal/: statemachine internal/statemachine, pagination internal/pagination.
• `providers/{aws,azure,gcp}` and `server/{aws,azure,gcp}` are unchanged — only their import prefixes gain /v2.
• No behavior changed in the move: the entrypoints (cloudemu.NewAWS(), NewAzure(), NewGCP()) and every driver, wire protocol, and error type are identical. The upgrade is a find-and-replace of the import prefix.

Features

AWS STS — SDK-compat (query protocol)

The real aws-sdk-go-v2 STS client now works against cloudemu: GetCallerIdentity, AssumeRole, and GetSessionToken return well-formed credentials/identity envelopes so code that resolves an identity or assumes a role before calling other services runs end-to-end.

AWS SSM Parameter Store — SDK-compat (#239)

AWS Systems Manager Parameter Store drives a new parameterstore service: PutParameter (with overwrite + version bump), GetParameter / GetParameters / GetParametersByPath (recursive), DeleteParameter(s), and parameter labels — including String, StringList, and SecureString types and typed ParameterNotFound / ParameterAlreadyExists errors.

S3 — multipart upload, tagging, and versioning

The S3 handler gains the advanced object surface the SDK exercises for large and mutable objects: multipart (CreateMultipartUpload UploadPart CompleteMultipartUpload / AbortMultipartUpload, parts assembled in PartNumber order), object tagging (PutObjectTagging / GetObjectTagging / DeleteObjectTagging), and versioning (PutBucketVersioning plus version-aware GetObject / DeleteObject).

Azure Queue Storage + Table Storage — SDK-compat (#243)

Two Azure data-plane services land: Queue Storage (queue create/delete, put / get / peek / update / delete message with visibility-timeout and dequeue-count semantics) and Table Storage (table CRUD; insert / upsert / merge / replace / delete entity and OData-style query). Both speak the real azure-sdk-for-go wire format.

Azure AI — CognitiveServices + Machine Learning (#232)

Azure AI emulation across ARM and data plane: CognitiveServices accounts (ARM lifecycle) plus an assistants data plane, and Azure Machine Learning workspaces and their child resources. Unmodified azure-sdk-for-go clients drive both control-plane provisioning and data-plane calls.

Enhancements

CI/CD + security pipeline

A complete GitHub Actions setup lands with this release:

• `ci.yml` — build-vet (build then vet, sharing one cache), test, tidy, and advisory format / lint (golangci-lint v2) jobs, running in parallel with Go build + module caching (actions/cache@v4 with restore-keys) so repeat runs finish in well under a minute. Triggers on PRs and pushes to master, with concurrency cancel-in-progress.
• `security.yml` — govulncheck, gosec, CodeQL, and dependency-review (PR-only, fail-on high) as a separate parallel workflow.

Security hardening (CodeQL)

• Bounded `RunInstances` count across AWS EC2, Azure Virtual Machines, and GCP GCE — a request over the per-call maximum (1000) now returns InvalidArgument instead of attempting an uncontrolled allocation.
• Dropped a request-sized pre-allocation in Vertex AI FindNeighbors.

Correctness fixes

• S3 multipart now sorts parts by PartNumber before assembly, maps unknown upload IDs to NoSuchUpload, and rejects an empty CompleteMultipartUpload.
• SSM validates parameter labels and threads context through the PutParameter retry path.
• Azure Table supports UpsertEntity; Queue/Blob/Table shared-hostname collisions are documented.

Documentation

Every in-repo doc (architecture.md, services.md, features.md, getting-started.md) and the package overview were rewritten for the services/ / features/ / internal/ layout, and all import paths and badges updated to the /v2 module.

Technical Details

Full SDK-compat coverage. This release wires the last seven service domains through the SDK-compat HTTP layer, so every service driver cloudemu ships now speaks its cloud's real wire protocol across AWS, Azure, and GCP. Point the real aws-sdk-go-v2, azure-sdk-for-go, and cloud.google.com/go clients at a local endpoint and drive Load Balancer, Secrets, DNS, Cache, Logging, Notification, and Event Bus — no code changes, no Docker, no accounts. Completes #143.

Features

Load Balancer — SDK-compat across AWS, Azure, and GCP

AWS ELBv2, Azure Load Balancer, and GCP Load Balancing now drive the existing loadbalancer driver: load balancers, target groups / backend pools, listeners / rules, and target registration & health — with each provider's native create / describe / delete semantics and typed errors.

Secrets — SDK-compat across AWS, Azure, and GCP

AWS Secrets Manager, Azure Key Vault (secrets data plane), and GCP Secret Manager now speak their real protocols against the secrets driver: secret lifecycle, value versioning / staging, and access — including Key Vault's bearer-challenge handshake.

DNS — SDK-compat across AWS, Azure, and GCP

AWS Route 53, Azure DNS, and GCP Cloud DNS drive the dns driver: hosted zones / managed zones and record sets (A/AAAA/CNAME/TXT/NS/PTR), with real change-batch / record semantics and typed errors.

Cache — SDK-compat across AWS, Azure, and GCP

AWS ElastiCache, Azure Cache for Redis, and GCP Memorystore now serve the cache driver's cluster/instance control plane: create / describe / list / delete with each provider's LRO and error shapes.

Logging — SDK-compat across AWS, Azure, and GCP

AWS CloudWatch Logs, Azure Log Analytics, and GCP Cloud Logging drive the logging driver: log groups / streams (or workspaces), put / get / filter log events, with AWS epoch-millis timestamps and typed errors.

Notification — SDK-compat across AWS, Azure, and GCP

AWS SNS, Azure Notification Hubs, and GCP FCM drive the notification driver: topics / subscriptions / publish (SNS), namespaces & hubs (Notification Hubs), and messages:send (FCM).

Event Bus — SDK-compat across AWS, Azure, and GCP

AWS EventBridge, Azure Event Grid, and GCP Eventarc drive the eventbus driver: event buses / topics / triggers, rules & targets, and event publishing.

Technical Details

Features

Container Registry — SDK-compat servers across AWS, Azure, and GCP

Point the real registry clients at in-memory backends: AWS ECR (aws-sdk-go-v2), GCP Artifact Registry (artifactregistry/v1), and Azure Container Registry (azcontainerregistry) now drive the existing container-registry driver over each cloud's native wire protocol — repository and image/tag operations, matching each provider's real create / list / delete semantics and typed error codes.

Enhancements

IAM — managed policy versions across AWS, Azure, and GCP

Managed policies now carry versions: create, get, list, set-default, and delete, mirroring AWS semantics — an auto-seeded v1, monotonic never-reused version IDs, a five-version cap, and a protected default version whose document becomes the policy's effective document. Wired through the AWS IAM SDK surface with faithful error codes; Azure and GCP are covered at the portable API level.

Technical Details

Features

AWS SageMaker — in-memory emulation + SDK-compat server

Point the real aws-sdk-go-v2 SageMaker client at an in-memory backend: models and endpoints (deploy / predict), training, processing, tuning, and batch-transform jobs, notebooks and Studio, pipelines, the model registry, feature store, and HyperPod-style clusters — with auto-metrics to CloudWatch and a portable Go API carrying the usual recording / metrics / rate-limit / error-injection / latency wrappers.

GCP Vertex AI — in-memory emulation + SDK-compat REST server

Datasets, the model registry and endpoints (deploy / predict), Gemini generateContent / streamGenerateContent / countTokens, tuning, custom / batch / hyperparameter-tuning jobs, pipelines, feature store, vector search, and ML metadata — with long-running-operation machinery, served over a REST surface the Vertex client can target.

Enhancements

Azure Databricks — faithful data-plane round-trips

Cluster, instance-pool, and SQL-warehouse settings that previously dropped between create and read now round-trip — custom tags, Photon runtime engine, pool idle-autotermination, and cluster policy / instance pool / Azure availability / source — and an explicit "never auto-stop" warehouse is honored. Query history is now served end-to-end.

Azure Resource Graph — Databricks discovery & type filtering

Databricks workspaces now appear in Resource Graph results, and where type in~ (...) type filters narrow correctly — including returning nothing (not everything) for a type the emulator doesn't model.

Technical Details