Why Rust​

The move to Rust was primarily about distribution and operational simplicity. Rust also brings stronger guarantees around performance and memory safety. Running everything in-process without Foreign Function Interface (FFI) boundaries simplifies the architecture while maintaining predictable resource usage.

Embedded Postgres Wire Protocol Server​

The most significant functional change in 2.0 is that stackql-deploy now runs the StackQL engine as an embedded in-process server over a local postgres wire protocol connection rather than shelling out to the StackQL binary as an external process.

There is nothing to start, stop, or configure. The server is lifecycle-managed by stackql-deploy itself and binds to localhost only - no port is exposed on the network, no inbound firewall rules needed in CI.

The previous model spawned a new StackQL process per operation. The embedded server keeps a persistent connection for the duration of a deployment run. For stacks with many resources, the reduction in process spawn overhead is noticeable - particularly on Windows where process creation is expensive.

Additional Features Added​

In addition to added the architectural change to use the embedded server, several other workflow improvements were added including:

• Enabling resource scoped variable exports in /*+ exists */ queries: When an exists query returns a named field (e.g. vpc_id) instead of count, the value is captured as a resource-scoped variable (this.vpc_id) and made available to all subsequent queries for that resource (e.g. statecheck, exports). This eliminates the need for redundant lookups to resolve resource identifiers between query stages.
• Support for capturing RETURNING payloads from DML operations: INSERT, UPDATE, and DELETE statements can include a RETURNING clause. Fields from the response can be mapped to resource-scoped variables via return_vals in the manifest, keyed by operation (create, update, delete). This allows identifiers assigned by the provider during creation to be used immediately without a round-trip query.
• Additional template filters: Including the to_aws_tag_filters filter, which converts global_tags to the AWS Resource Groups Tagging API TagFilters format, and type-preserving YAML-to-JSON serialization that maintains string types through the rendering pipeline.
• Improved logging and exception handling: Enhanced visibility simplifying troubleshooting.

Installation​

curl -L https://get-stackql-deploy.io | tar xzf -

Invoke-WebRequest https://get-stackql-deploy.io -OutFile stackql-deploy.zip
Expand-Archive stackql-deploy.zip -DestinationPath .

jobs:
  deploy:
    runs-on: ubuntu-latest
    env:
      GOOGLE_CREDENTIALS: ${{ secrets.GOOGLE_CREDENTIALS }}
    steps:
      - uses: actions/checkout@v4
      - uses: stackql/stackql-deploy-action@v2
        with:
          command: 'build'
          stack_dir: 'examples/my-stack'
          stack_env: 'prod'
          env_vars: 'GOOGLE_PROJECT=my-project'

      - name: Deploy Stack
        id: stackql-deploy
        uses: stackql/stackql-deploy-action@v2
        with:
          command: 'build'
          stack_dir: 'examples/my-stack'
          stack_env: 'prod'
          output_file: 'deployment-outputs.json'
          env_vars: 'GOOGLE_PROJECT=my-project'

      - name: Use outputs
        run: |
          echo '${{ steps.stackql-deploy.outputs.deployment_outputs }}' | jq .

cargo install stackql-deploy

Usage​

The CLI interface is unchanged from the Python version:

# deploy a stack
stackql-deploy build my-stack prod \
  --e GOOGLE_PROJECT=${GOOGLE_PROJECT}

# test a stack
stackql-deploy test my-stack prod \
  --e GOOGLE_PROJECT=${GOOGLE_PROJECT}

# tear down a stack
stackql-deploy teardown my-stack prod \
  --e GOOGLE_PROJECT=${GOOGLE_PROJECT}

# dry run
stackql-deploy build my-stack prod \
  --e GOOGLE_PROJECT=${GOOGLE_PROJECT} \
  --dry-run

Stack files and stackql_manifest.yml structure are unaffected - no migration work needed.

Python Package Deprecation​

stackql-deploy 1.9.4 on PyPi is the final Python release. The Python source repository is archived. If you have pip install stackql-deploy in any scripts or CI pipelines, replace it with one of the install methods above. The 1.9.4 package remains on PyPi and installable, but will not receive updates.

Links​

• GitHub: github.com/stackql/stackql-deploy
• crates.io: crates.io/crates/stackql-deploy
• StackQL docs: stackql.io/docs

How It Works​

Download the latest release of stackql, then run the convenience script included (similar scripts are included for other cloud provider terminals - e.g. AWS Cloud Shell).

curl -L https://bit.ly/stackql-zip -O && unzip stackql-zip
sh stackql-databricks-shell.sh

Example Queries​

Here are the sample queries run in the video, just change the deployment_name for your workspace.

User entitlements

SELECT
  deployment_name,
  id,
  userName,
  displayName,
  entitlement
FROM databricks_workspace.iam.vw_user_entitlements
WHERE deployment_name = 'dbc-74aa95f7-8c7e';

All workspace settings

SELECT * FROM
  databricks_workspace.settings.vw_all_settings
WHERE deployment_name = 'dbc-74aa95f7-8c7e';

Tag policies filtered by key prefix

SELECT
  tag_key as key,
  description
FROM databricks_workspace.tags.tag_policies
WHERE deployment_name = 'dbc-74aa95f7-8c7e'
AND key LIKE 'class%';

Catalog count by type

SELECT
  catalog_type,
  COUNT(*) as num_catalogs
FROM databricks_workspace.catalog.catalogs
WHERE deployment_name = 'dbc-74aa95f7-8c7e'
GROUP BY catalog_type;

Provider Coverage​

The databricks_workspace provider covers workspace related services, the databricks_account provider covers account-level operations including provisioning, billing, and account IAM.

The web terminal flow covers workspace-scoped queries using the token of the logged-in user. For account-level queries (provisioning, billing, account IAM), you need a Databricks service principal with account admin rights and OAuth2 credentials:

export DATABRICKS_ACCOUNT_ID="your-account-id"
export DATABRICKS_CLIENT_ID="your-client-id"
export DATABRICKS_CLIENT_SECRET="your-client-secret"

These are the same variables used by the Databricks CLI and Terraform provider, so if you already have those configured the auth story is identical.

Get Started​

Full provider documentation:

• Databricks Workspace Provider for StackQL
• Databricks Account Provider for StackQL

Visti StackQL on GitHub.

Provider Structure​

The following updated providers are available:

Coverage​

There are over 30 services, 300+ resources, and 983 operations spanning IAM, compute, catalog, billing, jobs, ML, serving, sharing, vector search, and more.

Example Queries​

List workspaces in an account​

SELECT
  workspace_id,
  workspace_name,
  workspace_status,
  aws_region,
  compute_mode,
  deployment_name,
  datetime(creation_time/1000, 'unixepoch') as creation_date_time
FROM databricks_account.provisioning.workspaces
WHERE account_id = 'ebfcc5a9-9d49-4c93-b651-b3ee6cf1c9ce';

Query account users and roles​

SELECT
  id as user_id,
  displayName as display_name,
  userName as user_name,
  active,
  IIF(JSON_EXTRACT(roles,'$[0].value') = 'account_admin', 'true', 'false') as is_account_admin
FROM databricks_account.iam.account_users
WHERE account_id = 'ebfcc5a9-9d49-4c93-b651-b3ee6cf1c9ce';

List catalogs in a workspace​

SELECT
  full_name,
  catalog_type,
  comment,
  datetime(created_at/1000, 'unixepoch') as created_at,
  created_by,
  datetime(updated_at/1000, 'unixepoch') as updated_at,
  updated_by,
  enable_predictive_optimization
FROM databricks_workspace.catalog.catalogs
WHERE deployment_name = 'dbc-36ff48e3-4a69';

Download billable usage to CSV​

This one is worth calling out. You can pull billable usage data for a given period and write it straight to a CSV file:

./stackql exec \
  -o text \
  --hideheaders \
  -f billable_usage.csv \
  "SELECT contents
  FROM databricks_account.billing.billable_usage
  WHERE start_month = '2025-12'
  AND end_month = '2026-01'
  AND account_id = 'your-account-id'"

Authentication​

Both providers authenticate using OAuth2 with a Databricks service principal. Set the following environment variables:

export DATABRICKS_ACCOUNT_ID="your-account-id"
export DATABRICKS_CLIENT_ID="your-client-id"
export DATABRICKS_CLIENT_SECRET="your-client-secret"

These are the same variables used by Terraform, the Databricks SDKs, and the Databricks CLI.

Get Started​

Pull the providers:

registry pull databricks_account;
registry pull databricks_workspace;

Start querying via the shell or exec:

SELECT * FROM databricks_account.iam.account_groups WHERE account_id = 'your-account-id';

Full documentation is available at databricks-account-provider.stackql.io and databricks-workspace-provider.stackql.io. Let us know what you think on GitHub.

Resource Naming Convention​

Resources follow a clear pattern to differentiate operations:

This separation means listing thousands of resources won't trigger rate limits from individual GET calls:

-- Fast enumeration (list operation only)
SELECT bucket_name 
FROM awscc.s3.buckets_list_only 
WHERE region = 'us-east-1';

-- Full resource details (get operation)
SELECT * 
FROM awscc.s3.buckets 
WHERE region = 'us-east-1' 
AND data__Identifier = 'my-bucket';

Provider Coverage​

The awscc provider includes:

• 237 services and 2371 resources covering the breadth of AWS
• Full CRUDL support for all Cloud Control compatible resources
• Consistent schema derived from AWS CloudFormation resource specifications

Example Operations​

Create an S3 Bucket​

INSERT INTO awscc.s3.buckets (
  BucketName,
  region
)
SELECT 
  'my-new-bucket',
  'us-east-1';

Query EC2 Instances​

SELECT 
  instance_id,
  instance_type,
  tags
FROM awscc.ec2.instances
WHERE region = 'ap-southeast-2'
AND data__Identifier = 'i-1234567890abcdef0';

Delete a Resource​

DELETE FROM awscc.lambda.functions
WHERE data__Identifier = 'my-function'
AND region = 'us-east-1';

Enhanced Documentation​

The provider documentation at awscc.stackql.io now features:

• Interactive schema explorer with expandable nested property trees
• Complete field documentation including complex object structures
• Ready-to-use SQL examples for SELECT, INSERT, and DELETE operations
• IAM permissions reference for each resource operation

Get Started​

Pull the new provider:

stackql registry pull awscc

Query your AWS resources:

stackql shell
>> SELECT region, bucket_name FROM awscc.s3.buckets_list_only WHERE region = 'us-east-1';

Let us know your thoughts! Visit us and give us a star on GitHub.

StackQL Studios has joined the Linux Foundation and the Agentic AI Foundation (AAIF) as a Silver Member.

As agentic AI moves from experimentation toward production workloads, we believe the infrastructure layer matters. Open, interoperable standards will be essential for AI agents to work reliably across cloud providers, data platforms, and enterprise systems.

StackQL provides a SQL-based interface for querying, provisioning, and managing cloud infrastructure across providers. Our work on the StackQL MCP Server brings this capability to AI agents through the Model Context Protocol, enabling agents to interact with cloud resources using natural language while maintaining the governance and auditability that production systems require.

Joining AAIF aligns with our long-standing commitment to open-source infrastructure tooling. We look forward to contributing to the foundation's work on MCP, agent runtimes, and the broader ecosystem of standards that will shape how AI agents interact with the systems they manage.

More information about the Agentic AI Foundation is available at aaif.io.

New Service: Speech-to-Text v2​

The speechv2 service brings Cloud Speech-to-Text API v2 to StackQL with 6 resources:

Key features include support for multiple audio encodings (WAV, FLAC, MP3, OGG, WebM, MP4/AAC), translation capabilities, denoiser config, and KMS encryption support.

Vertex AI / AI Platform​

The largest update in this release with 87,000+ line changes introduces powerful new RAG and evaluation capabilities:

• RAG Resources: rag_corpora, rag_files, rag_engine_config for Retrieval-Augmented Generation
• Conversational AI: New chat resource
• Model Evaluation: evaluation_sets and evaluation_items for systematic model assessment
• New Resources: science, invoke, and openapi resources
• Performance: Enhanced cache_config for caching configurations

Discovery Engine​

Major enhancements (50,000+ line changes) for search and conversational AI:

• New assistants resource
• New sitemaps resource for site search
• New custom_models resource
• Enhanced sessions and answers for conversational search
• New authorized_views and authorized_view_sets for access control

Contact Center AI Insights​

Quality assurance and analytics improvements (20,000+ line changes):

• New qa_questions and qa_question_tags for quality assurance workflows
• New analysis_rules resource
• New segments resource
• New authorized_views with IAM policy support
• New datasets and views resources

BigQuery​

Enhanced governance and access control (18,000+ line changes):

• New routines_iam_policies for stored procedure/function IAM
• Enhanced row_access_policies

Healthcare API​

Expanded metrics and data mapping (15,000+ line changes):

• New data_mapper_workspaces_iam_policies
• Enhanced metrics: hl7_v2_store_metrics, dicom_store_metrics, series_metrics, study_metrics
• New instances_storage_info resource

Cloud Spanner​

Backup and security enhancements (14,000+ line changes):

• New backup_schedules with IAM support
• New databases_split_points resource
• New database_roles with IAM policies

Cloud SQL Admin​

New integration and management features (12,000+ line changes):

• New instances_entra_id_certificate for Microsoft Entra ID integration
• New instances_disk_shrink_config
• New instances_latest_recovery_time

GKE On-Prem​

Enhanced IAM across VMware and Bare Metal clusters (9,000+ line changes):

• Enhanced VMware cluster resources with IAM policies
• Enhanced Bare Metal cluster resources with IAM policies
• New vmware_node_pools and bare_metal_node_pools with IAM

Developer Connect​

Git integration improvements (3,500+ line changes):

• New git_repository_links_git_refs resource
• New users_self and users_access_token resources
• New token resources: read_token, read_write_token

Text-to-Speech​

Enhanced voices and text resources with new capabilities.

Get Started​

Update to the latest Google provider:

stackql registry pull google

Let us know your thoughts! Visit us and give us a star on GitHub.

Window Functions​

Window functions allow you to perform calculations across sets of rows related to the current row. Supported functions include:

• Ranking: ROW_NUMBER(), RANK(), DENSE_RANK(), NTILE()
• Offset: LAG(), LEAD(), FIRST_VALUE(), LAST_VALUE(), NTH_VALUE()
• Distribution: PERCENT_RANK(), CUME_DIST()
• Aggregates as window functions: SUM(), COUNT(), AVG(), etc. with OVER clause

Example: Ranking Contributors​

SELECT
    login,
    contributions,
    DENSE_RANK() OVER (ORDER BY contributions DESC) as rank
FROM github.repos.contributors
WHERE owner = 'stackql' AND repo = 'stackql';

Example: Running Totals​

SELECT
    login,
    contributions,
    SUM(contributions) OVER (ORDER BY contributions DESC) as running_total,
    ROUND(100.0 * contributions / SUM(contributions) OVER (), 2) as pct_of_total
FROM github.repos.contributors
WHERE owner = 'stackql' AND repo = 'stackql';

Common Table Expressions (CTEs)​

CTEs let you define temporary named result sets using the WITH clause. This simplifies complex queries by breaking them into logical components.

Example: Aggregating Across Multiple Resources​

WITH all_contributors AS (
    SELECT login, contributions
    FROM github.repos.contributors
    WHERE owner = 'stackql' AND repo = 'stackql'
    UNION ALL
    SELECT login, contributions
    FROM github.repos.contributors
    WHERE owner = 'stackql' AND repo = 'stackql-deploy'
)
SELECT
    DENSE_RANK() OVER (ORDER BY SUM(contributions) DESC) as rank,
    login,
    SUM(contributions) as total_contributions
FROM all_contributors
GROUP BY login
ORDER BY total_contributions DESC;

Documentation​

Full documentation is available:

• Window Functions
• WITH (CTEs)
• SELECT

Let us know your thoughts! Visit us and give us a star on GitHub.

What's in the Skill​

The skill covers the full provider development workflow:

• Provider document structure - The provider.yaml schema and service document layout
• OpenAPI extensions - All x-stackQL-* extensions including x-stackQL-resources, x-stackQL-config, x-stackQL-objectKey, and others
• Resource and method definitions - How to define resources, map methods to operations, and configure responses
• SQL verb mappings - Connecting REST operations to SELECT, INSERT, UPDATE, and DELETE
• Authentication patterns - API keys, service accounts, OAuth, and custom auth schemes
• Pagination handling - Request/response token configuration
• Response processing - JSONPath extraction, transformations, and schema handling

Download​

Grab the skill from the any-sdk repository:

Download stackql-provider-development.md

Usage​

With the skill loaded, you can ask Claude things like:

• "Create a provider definition for this API"
• "How do I map this endpoint to a SELECT operation?"
• "What's the correct objectKey syntax for this nested response?"
• "Help me configure pagination for this API"

Claude will have the full context of StackQL's OpenAPI extensions and provider patterns to work from.

Example​

Here's a sample interaction after loading the skill:

You: I have an API endpoint GET /users that returns {"data": {"users": [...]}}. 
     How do I set up the resource?

Claude: For that response structure, you'd configure the method like this:

methods:
  list:
    operation:
      $ref: '#/paths/~1users/get'
    response:
      mediaType: application/json
      openAPIDocKey: '200'
      objectKey: $.data.users

The objectKey uses JSONPath to extract the users array from the nested response.

Resources​

• StackQL Provider Registry
• any-sdk documentation
• StackQL documentation

⭐ Star us on GitHub

Background​

Recent research from ImprovingAgents.com tested 11 data formats to determine which ones LLMs parse most accurately. Using 1,000 synthetic employee records and 1,000 randomized queries, they measured how well different formats preserved data integrity through LLM processing.

The results:

Markdown-KV showed a 37% improvement over CSV and 16 percentage points over JSON. The tradeoff: it uses approximately 2.7x more tokens than CSV.

What is Markdown-KV?​

Markdown-KV uses hierarchical markdown headers with code blocks for key-value pairs:

# Query Results

## Record 1

id: i-1234567890abcdef0
name: prod-web-01
region: us-east-1
instance_type: t3.large
state: running


## Record 2

id: i-0987654321fedcba0
name: staging-web-01
region: us-west-2
instance_type: t3.medium
state: stopped

The format combines clear hierarchy, explicit key-value pairs, and readability for both humans and LLMs.

Usage​

from pystackql import StackQL

stackql = StackQL()

# Query with Markdown-KV output
result = stackql.execute(
    """
    SELECT instanceId, instanceType, state, availabilityZone 
    FROM aws.ec2.instances 
    WHERE region = 'us-east-1'
    """,
    output='markdownkv'
)

# Use with LLMs
response = llm_client.complete(
    f"Identify instances that should be stopped:\n\n{result}"
)

Works in server mode too:

stackql = StackQL(server_mode=True)

result = stackql.execute(
    "SELECT name, region, encryption FROM google.storage.buckets WHERE project = 'my-project'",
    output='markdownkv'
)

When to Use It​

Markdown-KV is useful when:

• Feeding infrastructure data to LLMs for analysis, security reviews, or recommendations
• Building RAG pipelines that need to accurately retrieve and reason about infrastructure
• Accuracy matters more than token efficiency (infrastructure decisions typically do)
• Query results are focused datasets (most StackQL queries are)

The token cost is a real tradeoff, but infrastructure queries typically return targeted result sets, not massive datasets. When you're asking an LLM to analyze your production environment, accuracy matters.

Getting Started​

Update pystackql:

pip install --upgrade pystackql

Add output='markdownkv' to your execute calls or in the StackQL object instantiation:

result = stackql.execute(query, output='markdownkv')

Resources​

• ImprovingAgents.com research on LLM data formats
• pystackql v3.8.2 changelog
• pystackql documentation
• StackQL documentation

The Markdown-KV output format is available in pystackql v3.8.2 and later.

⭐ Star us on GitHub and join our community!

What is the Model Context Protocol?​

The Model Context Protocol is an open standard that enables AI applications to securely connect to external data sources and tools. By running StackQL as an MCP server, AI agents like Claude, ChatGPT, and other LLM-based assistants can interact with your cloud infrastructure using StackQL's powerful SQL-based query capabilities.

Why MCP + StackQL?​

Combining MCP with StackQL creates a powerful interface for AI-assisted infrastructure management:

• Natural Language Infrastructure Queries: Ask questions about your cloud resources in plain English and get structured data back
• Multi-Cloud Support: Access resources across AWS, Google Cloud, Azure, and 100+ other providers through a single interface
• Secure and Standardized: MCP provides a secure, standardized way for AI agents to interact with your infrastructure
• SQL-Powered Analytics: Leverage StackQL's full SQL capabilities including joins, aggregations, and complex queries through AI agents

Deployment Options​

StackQL's MCP server supports three flexible deployment modes to suit different architectural requirements:

1. Standalone MCP Server​

Perfect for development and AI agent integration:

stackql mcp \
  --mcp.server.type=http \
  --mcp.config '{"server": {"transport": "http", "address": "127.0.0.1:9912"}}'

2. Dual-Protocol Server (In-Memory)​

Run both MCP and PostgreSQL wire protocol simultaneously with high-performance in-memory communication:

stackql srv \
  --mcp.server.type=http \
  --mcp.config '{"server": {"transport": "http", "address": "127.0.0.1:9912"}}' \
  --pgsrv.port 5665

This mode is ideal when you need both AI agent access and traditional database client connectivity.

3. Reverse Proxy with TLS​

For production environments requiring distributed deployments and encrypted connections:

stackql srv \
  --mcp.server.type=reverse_proxy \
  --mcp.config '{"server": {"tls_cert_file": "/path/to/cert.pem", "tls_key_file": "/path/to/key.pem", "transport": "http", "address": "127.0.0.1:9004"}, "backend": {"dsn": "postgres://stackql:stackql@127.0.0.1:5446?default_query_exec_mode=simple_protocol"}}' \
  --pgsrv.port 5446

Available MCP Tools​

When running as an MCP server, StackQL exposes several tools that AI agents can invoke:

Integration with Claude Desktop​

To integrate StackQL with Claude Desktop, add this configuration to your MCP settings file (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "stackql": {
      "command": "stackql",
      "args": [
        "mcp",
        "--mcp.server.type=http",
        "--mcp.config",
        "{\"server\": {\"transport\": \"http\", \"address\": \"127.0.0.1:9912\"}}"
      ]
    }
  }
}

Example Use Cases​

Once configured, you can ask your AI assistant questions like:

• "Show me all my EC2 instances across all AWS regions"
• "List all Google Cloud Storage buckets with public access"
• "Find all Azure virtual machines that haven't been updated in 30 days"
• "Compare compute costs across AWS, Azure, and GCP"
• "Show me IAM policies that grant admin access in my Google Cloud projects"

The AI agent will use StackQL's MCP server to execute the appropriate queries and return structured results.

Example Query Flow​

Here's how an AI agent interacts with StackQL via MCP:

# AI agent lists available providers
Tool: list_providers
Response: ["google", "aws", "azure", "github", ...]

# AI agent explores a provider's services
Tool: list_services
Args: {"provider": "google"}
Response: ["compute", "storage", "cloudresourcemanager", ...]

# AI agent executes a query
Tool: query_v2
Args: {"sql": "SELECT name, status FROM google.compute.instances WHERE project = 'my-project' AND zone = 'us-east1-a'"}
Response: [{"name": "instance-1", "status": "RUNNING"}, ...]

Getting Started​

1. Download StackQL version 0.9.250 or later from stackql.io/install

2. Set up provider authentication:

export GOOGLE_CREDENTIALS=$(cat /path/to/credentials.json)
export AWS_ACCESS_KEY_ID=your-access-key
export AWS_SECRET_ACCESS_KEY=your-secret-key

3. Start the MCP server:

stackql mcp \
  --mcp.server.type=http \
  --mcp.config '{"server": {"transport": "http", "address": "127.0.0.1:9912"}}'

4. Configure your AI assistant to use the StackQL MCP server (see MCP documentation for details)

Documentation​

For comprehensive documentation on configuring and using the MCP server, including:

• Detailed configuration options
• TLS/mTLS setup
• Architecture considerations
• Testing and troubleshooting

Visit the MCP command documentation.

What's Next?​

We're actively developing additional MCP capabilities and welcome your feedback. Future enhancements may include:

• Enhanced resource provisioning and lifecycle management through MCP
• Built-in prompt templates for common infrastructure queries
• Extended tool catalog for specialized operations
• Support for additional MCP transport protocols

Try It Out!​

The MCP server feature is available now in StackQL 0.9.250. We'd love to hear about your experiences integrating StackQL with AI agents. Share your use cases, provide feedback, or contribute to the project on GitHub.

⭐ Star us on GitHub and join our community!

• coverage for the latest Datadog features
• simplified service organization
• enhanced user documentation

For more see the Datadog Provider User Docs.

⭐ us on GitHub and join our community!

Provider Overview​

The Linode provider offers comprehensive access to 20 services covering the entire Linode platform, with 136 resources and 425 methods, allowing you to extract data and insights from your Linode environment using familiar SQL syntax.

Key Services​

The provider includes access to:

• Compute: Manage Linode instances and configurations
• Storage: Control volumes and object storage
• Networking: Handle IPs, VLANs, VPCs, and firewall rules
• Kubernetes: Administer LKE clusters and node pools
• Databases: Manage Linode's database service
• Account & Billing: Access account information and billing details

Example Queries​

Get Account Information​

SELECT 
  company,
  country,
  balance,
  balance_uninvoiced,
  active_since
FROM linode.account.account;

List Database Engines​

SELECT
  id,
  engine,
  version
FROM linode.databases.engines;

View Regional Availability​

SELECT
  available,
  plan,
  region
FROM linode.regions.availability;

List Linode Instances​

SELECT
  id,
  label,
  region,
  status,
  type,
  ipv4,
  tags
FROM linode.linode.instances;

Getting Started​

To use the Linode provider, simply register it and set your authentication:

-- Pull the provider
registry pull linode;

-- Set your authentication
SET linode.global.auth.credentialsenvvar = 'LINODE_TOKEN';

⭐ us on GitHub and join our community!

The Deno Deploy provider offers comprehensive coverage of the Deno Deploy API, organized into logical services that mirror Deno's resource structure:

With the deno provider for StackQL, you can now include Deno Deploy in your infrastructure-as-code workflows, analytics dashboards, and cross-cloud orchestration processes using the same SQL syntax you use for other cloud providers.

For more information on the Deno Deploy provider for StackQL, see the Deno Deploy Provider Docs which provides detailed documentation for every resource and method, along with ready-to-use SQL examples.

Getting Started​

To start using the deno provider, simply pull it from the StackQL registry:

registry pull deno;

You'll need to set up your authentication by exporting your Deno API token:

export DENO_DEPLOY_TOKEN="your_deno_api_token"

Then you can begin querying your Deno Deploy resources:

-- List all projects in an organization
SELECT 
  id,
  name,
  description,
  createdAt,
  updatedAt
FROM deno.project.projects
WHERE organizationId = 'your-org-id';

|-----------------------------|-------------|--------------------------------------|----------------------|-----------------------------|
|          createdAt          | description |                  id                  |         name         |          updatedAt          |
|-----------------------------|-------------|--------------------------------------|----------------------|-----------------------------|
| 2022-12-13T04:20:13.379555Z |             | 34f9440f-3275-40e2-b327-2ea65269feb5 | stackql-dev-registry | 2025-09-06T00:47:04.579279Z |
|-----------------------------|-------------|--------------------------------------|----------------------|-----------------------------|
| 2022-12-13T04:16:22.054548Z |             | 616de983-3e37-4f44-a99f-b6bb5c59e80a | stackql-registry     | 2025-09-06T01:22:46.872203Z |
|-----------------------------|-------------|--------------------------------------|----------------------|-----------------------------|

-- List deployments with key information
SELECT
  id,
  description,
  status,
  JSON_EXTRACT(domains, '$[0]') as domain,
  JSON_EXTRACT("databases", '$.default') as db_id,
  createdAt,
  updatedAt
FROM deno.deployment.deployments
WHERE projectId = 'your-project-id'
AND "order" = 'desc';

|--------------|--------------------------------|---------|----------------------------------------|--------------------------------------|-----------------------------|-----------------------------|
|      id      |          description           | status  |                 domain                 |                db_id                 |          createdAt          |          updatedAt          |
|--------------|--------------------------------|---------|----------------------------------------|--------------------------------------|-----------------------------|-----------------------------|
| pe60nqshxq3g | Latest deployment              | success | example.com                            | 8971aec3-f72f-44c4-bc9f-0b2a513bd9fc | 2025-09-06T01:22:41.740151Z | 2025-09-06T01:22:49.067315Z |
|--------------|--------------------------------|---------|----------------------------------------|--------------------------------------|-----------------------------|-----------------------------|

⭐ us on GitHub and join our community!

What's Changed​

The updated DigitalOcean provider features a more granular and logical organization of services that mirrors DigitalOcean's API architecture more closely. Here is a summary of the services included in the latest digitalocean provider:

Enhanced Documentation​

The new DigitalOcean Provider Docs provide comprehensive documentation on how to use the new digitalocean provider including ready-to-use SQL examples for each resource and method. A standout feature is the copy-paste functionality for all SQL queries, making it incredibly easy to:

1. Compose Infrastructure-as-Code workflows: Each method documentation includes working SQL examples that can be directly copied into your deployment scripts or CI/CD pipelines. Simply click the copy button next to any example to get production-ready SQL code.

2. Build analytics dashboards: Create sophisticated cross-service queries by combining examples from different resources. The documentation's consistent query formatting makes it simple to join related data across multiple DigitalOcean services.

3. Develop governance reports: Copy baseline queries and customize them for your specific compliance needs. The pre-formatted SQL provides the perfect starting point for custom reporting.

Gradient AI Platform Support​

A standout addition to this release is comprehensive support for DigitalOcean's Gradient AI Platform through the new genai service. This enables developers to:

• Deploy and manage AI models using familiar SQL syntax
• Monitor AI workloads alongside other cloud resources
• Incorporate AI capabilities into infrastructure-as-code workflows
• Create cross-service orchestrations that leverage AI capabilities

Getting Started​

To start using the updated digitalocean provider, simply pull the latest version from stackql shell or stackql registry command:

registry pull digitalocean;

Then you can begin querying your DigitalOcean resources with SQL:

-- List all droplets
SELECT
  id,
  name,
  status,
  size_slug,
  JSON_EXTRACT(size, '$.vcpus') as vcpus,
  JSON_EXTRACT(size, '$.memory') as memory,
  JSON_EXTRACT(size, '$.disk') as disk_size_gb,
  JSON_EXTRACT(size, '$.price_hourly') as price_hourly,
  JSON_EXTRACT(size, '$.price_monthly') as price_monthly
FROM digitalocean.compute.droplets;

|-----------|---------------------------------------|--------|------------------------|-------|--------|--------------|--------------|---------------|
|    id     |                 name                  | status |       size_slug        | vcpus | memory | disk_size_gb | price_hourly | price_monthly |
|-----------|---------------------------------------|--------|------------------------|-------|--------|--------------|--------------|---------------|
| 457265395 | ubuntu-s-1vcpu-1gb-35gb-intel-syd1-01 | active | s-1vcpu-1gb-35gb-intel |     1 |   1024 |           35 |       0.0119 |             8 |
|-----------|---------------------------------------|--------|------------------------|-------|--------|--------------|--------------|---------------|
| 510398669 | pool-urzofvwy7-l5vvz                  | active | s-2vcpu-4gb            |     2 |   4096 |           80 |      0.03571 |            24 |
|-----------|---------------------------------------|--------|------------------------|-------|--------|--------------|--------------|---------------|

-- List all Kubernetes clusters
SELECT 
  id,
  name,
  cluster_subnet,
  region,
  JSON_EXTRACT(status, '$.state') as state
FROM 
  digitalocean.kubernetes.clusters;

|--------------------------------------|------------------------------------|----------------|--------|---------|
|                  id                  |                name                | cluster_subnet | region |  state  |
|--------------------------------------|------------------------------------|----------------|--------|---------|
| 52d8fa14-eca0-46c8-80a8-8aae70a2c82a | k8s-1-33-1-do-2-syd1-1753698369839 | 10.150.0.0/16  | syd1   | running |
|--------------------------------------|------------------------------------|----------------|--------|---------|

Using the App Platform Functions​

The apps services provide access to DigitalOcean's modern deployment platforms. Here's an example of how to list your deployed applications:

-- List all deployed applications
SELECT
  id,
  default_ingress,
  active_deployment,
  created_at,
  updated_at,
  region,
  tier_slug
FROM
  digitalocean.apps.apps;

Using the GenAI Service​

The new genai service provides access to DigitalOcean's Gradient AI Platform capabilities. Here's an example of how to list deployed agents:

-- List all deployed AI agents
SELECT
  name,
  uuid,
  url,
  project_id,
  created_at,
  updated_at,
  region,
  temperature
FROM
  digitalocean.genai.agents;

Use Cases for the DigitalOcean Provider​

1. Infrastructure as Code: Manage your DigitalOcean resources alongside other cloud providers in a unified IaC approach, see stackql-deploy.

2. Cost Optimization: Identify unused resources and opportunities for cost savings with queries that expose pricing information across all resource types.

3. Security and Compliance: Audit firewall rules, network configurations, and access patterns to ensure compliance with security policies.

4. Performance Monitoring: Track resource utilization, database performance, and identify optimization opportunities.

5. Cross-Provider Orchestration: Build workflows that span DigitalOcean and other resource providers, enabling sophisticated data and infrastructure pipelines.

6. AI-Enhanced Infrastructure: Leverage the new GenAI service to incorporate AI capabilities into your infrastructure management workflows.

7. Automated Reporting: Create automated reports on DigitalOcean usage, performance, and costs.

Provider Metrics​

The latest DigitalOcean provider includes:

• 15 services
• 192 resources
• 516 total methods
• 254 selectable methods

This comprehensive coverage ensures you can manage and query virtually all aspects of your DigitalOcean infrastructure using familiar SQL syntax.

⭐ us on GitHub and join our community!

What's Changed​

The updated Okta provider features a more granular and logical organization of services that mirrors Okta's API architecture more closely. Here is a summary of the services included in the latest okta provider:

Enhanced Documentation​

The new Okta Provider Docs provide comprehensive documentation on how to use the new okta provider including ready-to-use SQL examples for each resource and method. A standout feature is the copy-paste functionality for all SQL queries, making it incredibly easy to:

1. Compose Infrastructure-as-Code workflows: Each method documentation includes working SQL examples that can be directly copied into your deployment scripts or CI/CD pipelines. Simply click the copy button next to any example to get production-ready SQL code.

2. Build analytics dashboards: Create sophisticated cross-service queries by combining examples from different resources. The documentation's consistent query formatting makes it simple to join related data across multiple Okta services.

3. Develop governance reports: Copy baseline queries and customize them for your specific compliance needs. The pre-formatted SQL provides the perfect starting point for custom reporting.

Getting Started​

To start using the updated okta provider, simply pull the latest version from stackql shell or stackql registry command:

registry pull okta;

Then you can begin querying your Okta resources with SQL:

-- Get all users and their group assignments
SELECT 
  u.id, 
  JSON_EXTRACT(u.profile, '$.email') as email,
  u.status, 
  JSON_EXTRACT(g.profile, '$.name') as group_name
FROM 
  okta.user.users u
JOIN 
  okta.group.users gu ON u.id = gu.user_id
JOIN 
  okta.group.groups g ON gu.group_id = g.id
WHERE subdomain = 'my-company';  

-- Report on users login and activity
SELECT
id,
activated,
created,
lastLogin,
lastUpdated,
passwordChanged,
JSON_EXTRACT(profile, '$.email') as email,
JSON_EXTRACT(profile, '$.firstName') as first_name,
JSON_EXTRACT(profile, '$.lastName') as last_name,
status,
statusChanged
FROM okta.users.users
WHERE subdomain = 'my-company';  

-- Inventory network zones for security audit
SELECT 
  name, 
  type, 
  status, 
  gateways, 
  proxies
FROM 
  okta.networkzone.zones
WHERE subdomain = 'my-company'; 

-- Review authorization servers and scopes
SELECT 
  a.name as auth_server_name,
  s.name as scope_name,
  s.description
FROM 
  okta.authorizationserver.authorizationservers a
JOIN 
  okta.authorizationserver.scopes s ON a.id = s.server_id
WHERE subdomain = 'my-company'; 

Use Cases for the Okta Provider​

1. Infrastructure as Code: Manage your Okta resources alongside other cloud providers in a unified IaC approach, see stackql-deploy.

2. Cost Optimization: Identify unused resources and opportunities for cost savings.

3. Security and Compliance: Audit account roles, permissions, and access patterns to ensure compliance with security policies.

4. Performance Monitoring: Track query performance, warehouse utilization, and identify optimization opportunities.

5. Cross-Provider Orchestration: Build workflows that span Okta and other resource providers, enabling sophisticated data and infrastructure pipelines.

6. Automated Reporting: Create automated reports on Okta usage, performance, and costs.

⭐ us on GitHub and join our community!

What's New​

The latest release introduces several new services to the google provider, expanding your ability to manage and query Google Cloud resources:

• API Hub: Centrally manage and discover APIs across your organization
• Area Insights: Access location-based insights and analytics
• Cloud Location Finder: Identify optimal Google Cloud regions for your workloads
• Gemini Cloud Assist: Leverage Google's AI assistant for cloud operations
• Managed Kafka: Work with Google's fully-managed Apache Kafka service
• Observability: Enhanced monitoring and observability services
• Parallel Store: Interact with Google's high-performance storage solution
• Parameter Manager: Manage configuration parameters across services
• SaaS Service Management: Tools for managing SaaS offerings on Google Cloud
• Secure Source Manager: Google's secure, fully-managed source control service
• Security Posture: Assess and improve your cloud security posture
• Storage Batch Operations: Perform batch operations on Cloud Storage resources

Enhanced Documentation​

We've also released enhanced user documentation to help you get the most out of these providers. Check out our comprehensive docs:

• Firebase Provider
• Google Provider
• Google Admin Provider
• Google Workspace Provider

Getting Started​

To start using these updated providers, simply pull the latest version from stackql shell or stackql registry command:

registry pull google;
registry pull googleadmin;
registry pull googleworkspace;
registry pull firebase;

Then you can begin querying your Google resources with SQL:

SELECT name, region, status 
FROM google.compute.instances
WHERE project = 'my-project';

Use Cases for the Google Provider​

The Google provider for StackQL opens up numerous possibilities:

1. Infrastructure as Code: Manage your Google resources alongside other cloud providers in a unified IaC approach, see stackql-deploy.

2. Cost Optimization: Identify unused resources and opportunities for cost savings.

3. Security and Compliance: Audit account roles, permissions, and access patterns to ensure compliance with security policies.

4. Performance Monitoring: Track query performance, warehouse utilization, and identify optimization opportunities.

5. Cross-Provider Orchestration: Build workflows that span Google and other cloud providers, enabling sophisticated data and infrastructure pipelines.

6. Automated Reporting: Create automated reports on Google usage, performance, and costs.

⭐ us on GitHub and join our community!

The Snowflake provider for StackQL gives you the ability to:

• Query Snowflake metadata and statistics using SQL
• Monitor warehouse, database, and query performance
• Analyze resource usage and optimize costs
• Integrate Snowflake management with your existing cloud infrastructure
• Build cross-provider workflows and automation

Full documentation for the Snowflake provider is available here.

Getting Started​

Getting started is as easy as...

REGISTRY PULL snowflake;

Example Queries​

Let's explore some powerful examples of what you can do with the Snowflake provider for StackQL.

Analyzing Warehouses​

SELECT 
  size, 
  count(*) as num_warehouses
FROM 
  snowflake.warehouse.warehouses
WHERE 
  endpoint = 'OKXVNMC-VH34026'
GROUP BY 
  size;

|---------|----------------|
|  size   | num_warehouses |
|---------|----------------|
| X-Small |             12 |
|---------|----------------|
| Small   |              8 |
|---------|----------------|
| Medium  |              5 |
|---------|----------------|
| Large   |              3 |
|---------|----------------|
| X-Large |              1 |
|---------|----------------|

Other fields for the warehouses resource include : name, warehouse_type, state, scaling_policy, auto_suspend, auto_resume, resource_monitor, enable_query_acceleration, query_acceleration_max_scale_factor, max_concurrency_level, owner, warehouse_credit_limit, target_statement_size and more.

Table Analysis​

SELECT 
  name, 
  bytes, 
  data_retention_time_in_days, 
  table_type 
FROM 
  snowflake.table.tables 
WHERE 
  database_name = 'SNOWFLAKE_SAMPLE_DATA' 
  AND schema_name = 'TPCH_SF10' 
  AND endpoint = 'OKXVNMC-VH34026' 
ORDER BY 
  bytes DESC;

|----------|------------|-----------------------------|------------|
|   name   |   bytes    | data_retention_time_in_days | table_type |
|----------|------------|-----------------------------|------------|
| LINEITEM | 1717059584 |                           1 | NORMAL     |
|----------|------------|-----------------------------|------------|
| ORDERS   |  446439424 |                           1 | NORMAL     |
|----------|------------|-----------------------------|------------|
| PARTSUPP |  373145600 |                           1 | NORMAL     |
|----------|------------|-----------------------------|------------|
| CUSTOMER |  108249088 |                           1 | NORMAL     |
|----------|------------|-----------------------------|------------|
| PART     |   52776960 |                           1 | NORMAL     |
|----------|------------|-----------------------------|------------|
| SUPPLIER |    6791168 |                           1 | NORMAL     |
|----------|------------|-----------------------------|------------|
| NATION   |       4096 |                           1 | NORMAL     |
|----------|------------|-----------------------------|------------|
| REGION   |       4096 |                           1 | NORMAL     |
|----------|------------|-----------------------------|------------|

Other Services and Resources​

Other notable resources which can be provisioned, managed or queried using the snowflake provider for stackql include:

alerts, api_integrations, catalog_integrations, compute_pools, databases, database_roles, dynamic_tables, event_tables, external_volumes, functions, grants, iceberg_tables, image_repositories, network_policies, notebooks, notification_integrations, pipes, procedures, roles, schemas, stages, streams, tasks, users, user_defined_functions, views, and more!

Use Cases for the Snowflake Provider​

The Snowflake provider for StackQL opens up numerous possibilities:

1. Infrastructure as Code: Manage your Snowflake resources alongside other cloud providers in a unified IaC approach, see stackql-deploy.

2. Cost Optimization: Identify unused resources, inefficient warehouses, and opportunities for cost savings.

3. Security and Compliance: Audit account roles, permissions, and access patterns to ensure compliance with security policies.

4. Performance Monitoring: Track query performance, warehouse utilization, and identify optimization opportunities.

5. Cross-Provider Orchestration: Build workflows that span Snowflake and other cloud providers, enabling sophisticated data and infrastructure pipelines.

6. Automated Reporting: Create automated reports on Snowflake usage, performance, and costs.

⭐ us on GitHub and join our community!

[Action Required] AWS Lambda end of support for Node.js 18 [AWS Account: 824123456789] [EU-CENTRAL-1]

If you are like me and manage AWS accounts with numerous Lambda functions potentially deployed across multiple regions, you need to identify affected resources, in this case, Lambda node runtimes, which will be discontinued later this year.  

With stackql this task is easy...

1. Open AWS cloud shell in your AWS account (any region - it doesn't matter)
2. Download stackql

curl -L https://bit.ly/stackql-zip -O && unzip stackql-zip

3. Open an authenticated stackql command shell

sh stackql-aws-cloud-shell.sh

4. Run some analytic queries using stackql; here are some examples...

🔍 List all functions and runtimes across regions​

Run a stackql query to get the details about functions, runtimes, etc, deployed at any given time across one or more AWS regions.  You can include all 25 AWS regions; each query will be performed asynchronously - speeding up the results.

select 
  function_name, 
  region,
  runtime 
FROM aws.lambda.functions 
WHERE region IN ('us-east-1', 'eu-west-1');

|----------------------------------------------|---------------|------------|
| function_name                                | region        | runtime    |
|----------------------------------------------|---------------|------------|
| order-processing-handler                     | us-east-1     | nodejs16.x |
|----------------------------------------------|---------------|------------|
| payment-service-lambda                       | us-east-1     | nodejs18.x |
|----------------------------------------------|---------------|------------|
| user-notifications-service                   | us-east-1     | python3.8  |
|----------------------------------------------|---------------|------------|
| generate-invoice-pdf                         | eu-west-1     | nodejs18.x |
|----------------------------------------------|---------------|------------|
| realtime-data-stream-processor               | eu-west-1     | java11     |
|----------------------------------------------|---------------|------------|
| chat-message-router                          | eu-west-1     | nodejs20.x |
|----------------------------------------------|---------------|------------|
| scheduled-maintenance-checker                | ap-southeast-2| python3.11 |
|----------------------------------------------|---------------|------------|
| s3-image-thumbnail-generator                 | ap-southeast-2| nodejs16.x |
|----------------------------------------------|---------------|------------|
| email-delivery-status-updater                | ap-southeast-2| python3.8  |
|----------------------------------------------|---------------|------------|

📊 Group by runtime and region​

Perform an analytic query like a group by aggregate query such as...

select 
  runtime, 
  region, 
  count(*) as num_functions 
FROM aws.lambda.functions 
WHERE region IN ('us-east-1', 'eu-west-1', 'ap-southeast-2')
GROUP BY runtime, region;

|--------------|----------------|---------------|
| runtime      | region         | num_functions |
|--------------|----------------|---------------|
| nodejs16.x   | us-east-1      | 102           |
|--------------|----------------|---------------|
| nodejs18.x   | us-east-1      | 98            |
|--------------|----------------|---------------|
| python3.8    | us-east-1      | 138           |
|--------------|----------------|---------------|
| nodejs18.x   | eu-west-1      | 40            |
|--------------|----------------|---------------|
| java11       | eu-west-1      | 113           |
|--------------|----------------|---------------|
| nodejs20.x   | eu-west-1      | 120           |
|--------------|----------------|---------------|
| python3.11   | ap-southeast-2 | 384           |
|--------------|----------------|---------------|
| nodejs16.x   | ap-southeast-2 | 88            |
|--------------|----------------|---------------|
| python3.8    | ap-southeast-2 | 18            |
|--------------|----------------|---------------|

Using StackQL you can:

• Quickly spot functions running on runtimes like nodejs18.x that are approaching end of support.
• Plan your upgrades region-by-region with confidence.

⭐ us on GitHub and join our community!

registry pull aws;

Happy New Year 🎉. The latest AWS provider for StackQL is now available.  The StackQL AWS Provider by the numbers:

• 230 services
• 3174 resources
• 3917 methods

with additional new support for the following services:

• amazonmq - Managed message broker service for Apache ActiveMQ and RabbitMQ that simplifies setup and operation of open-source message brokers on AWS.
• applicationsignals - CloudWatch Application Signals automatically provides a correlated view of application performance that includes real user monitoring data and canaries.
• apptest - AWS mainframe modernization ppplication Testing
• connectcampaignsv2 - Amazon Connect Outbound Campaigns V2
• invoicing - Deploy and query invoice units allowing you separate AWS account costs and configures your invoice for each business entity
• launchwizard - Easily size, configure, and deploy third party applications on AWS
• pcaconnectorscep - AWS Private CA Connector for SCEP
• pcs - AWS Parallel Computing Service, easily run HPC workloads at virtually any scale
• rbin - Recycle Bin is a resource recovery feature that enables you to restore accidentally deleted snapshots and EBS-backed AMIs.
• s3tables - Amazon S3 Tables enabling Tabular Data Storage At Scale
• ssmquicksetup - AWS Systems Manager Quick Setup

And 150 new resources with some notable additions including:

• aws.apigateway.domain_name_access_associations
• aws.appconfig.deployments, aws.appconfig.deployment_strategies
• aws.batch.job_definitions
• aws.bedrock.flows, aws.bedrock.prompts
• aws.chatbot.custom_actions
• aws.cloudformation.guard_hooks, aws.cloudformation.lambda_hooks
• aws.cloudfront.anycast_ip_lists
• aws.cloudtrail.dashboards, aws.cloudwatch.dashboards
• aws.codepipeline.pipelines
• aws.cognito.user_pool_identity_providers
• aws.ec2.security_group_vpc_associations, aws.ec2.vpc_block_public_access_exclusions, aws.ec2.vpc_block_public_access_options
• aws.glue.crawlers, aws.glue.databases, aws.glue.jobs, aws.glue.triggers
• aws.guardduty.malware_protection_plans
• aws.iot.commands
• aws.memorydb.multi_region_clusters
• aws.rds.db_shard_groups
• aws.redshift.integrations
• aws.sagemaker.clusters, aws.sagemaker.endpoints
• aws.secretsmanager.resource_policies, aws.secretsmanager.rotation_schedules, aws.secretsmanager.secret_target_attachments
• aws.workspaces.workspaces_pools
• aws.wisdom.ai_agents, aws.wisdom.ai_prompts, aws.wisdom.ai_guardrails, aws.wisdom.message_templates
• and much more!

⭐ us on GitHub and join our community!

To get started, pull the providers from the registry as follows:  

registry pull databricks_account;
registry pull databricks_workspace;

databricks_account provider​

The databricks_account provider is used for account-level operations, including provisioning or managing users, groups, unity catalog metastores, workspaces, and account-level cloud resources used by workspaces (such as networking resources).  Services include:

stackql  >>show services in databricks_account;
|----------------------------|---------------|--------------------------------|
|             id             |     name      |             title              |
|----------------------------|---------------|--------------------------------|
| billing:v00.00.00000       | billing       | Account Billing                |
|----------------------------|---------------|--------------------------------|
| iam:v00.00.00000           | iam           | Identity and Access Management |
|----------------------------|---------------|--------------------------------|
| logging:v00.00.00000       | logging       | Log Delivery                   |
|----------------------------|---------------|--------------------------------|
| oauth:v00.00.00000         | oauth         | OAuth Integrations             |
|----------------------------|---------------|--------------------------------|
| provisioning:v00.00.00000  | provisioning  | Account Provisioning           |
|----------------------------|---------------|--------------------------------|
| settings:v00.00.00000      | settings      | Account Settings               |
|----------------------------|---------------|--------------------------------|
| unity_catalog:v00.00.00000 | unity_catalog | Unity Catalog                  |
|----------------------------|---------------|--------------------------------|

Some example databricks_account queries are shown here:

stackql  >>select *  from  databricks_account.iam.users where account_id = 'ebfcc5a9-9d49-4c93-b651-b3ee6cf1c9ce' and active = true;
|--------|--------------|-------------------------------------------------------------|------------|------------------|---------------------------------------------|---------------------------------------------|------------------|
| active | displayName  |                           emails                            | externalId |        id        |                    name                     |                    roles         
 |     userName     |
|--------|--------------|-------------------------------------------------------------|------------|------------------|---------------------------------------------|---------------------------------------------|------------------|
| true   | Jeffrey Aven | [{"primary":true,"type":"work","value":"javen@stackql.io"}] | null       | 5728205706991489 | {"familyName":"Aven","givenName":"Jeffrey"} | [{"type":"direct","value":"account_admin"}] | javen@stackql.io |
|--------|--------------|-------------------------------------------------------------|------------|------------------|---------------------------------------------|---------------------------------------------|------------------|

or..

stackql  >>SELECT applicationId,  displayName
stackql  >>FROM databricks_account.iam.service_principals, JSON_EACH(roles)
stackql  >>WHERE account_id = 'ebfcc5a9-9d49-4c93-b651-b3ee6cf1c9ce'
stackql  >>AND JSON_EXTRACT(json_each.value, '$.value') = 'account_admin';
|--------------------------------------|-------------|
|            applicationId             | displayName |
|--------------------------------------|-------------|
| 0b7b23de-3e7d-4432-812c-cf517e079a22 | stackql     |
|--------------------------------------|-------------|

or..

stackql  >>select
stackql  >>workspace_id,
stackql  >>workspace_name,
stackql  >>deployment_name,
stackql  >>workspace_status,
stackql  >>pricing_tier,
stackql  >>aws_region,
stackql  >>credentials_id,
stackql  >>storage_configuration_id
stackql  >>from
stackql  >>databricks_account.provisioning.workspaces where account_id = 'ebfcc5a9-9d49-4c93-b651-b3ee6cf1c9ce';
|------------------|----------------|-------------------|------------------|--------------|------------|--------------------------------------|--------------------------------------|
|   workspace_id   | workspace_name |  deployment_name  | workspace_status | pricing_tier | aws_region |            credentials_id            |       storage_configuration_id       |
|------------------|----------------|-------------------|------------------|--------------|------------|--------------------------------------|--------------------------------------|
| 1583879855205171 | stackql-test   | dbc-ddbc0f51-c9cf | RUNNING          | PREMIUM      | us-west-2  | dcacd875-c782-46ea-9d3e-8307975d758a | e52e029f-24bb-4a75-99c3-7796c202dd89 |
|------------------|----------------|-------------------|------------------|--------------|------------|--------------------------------------|--------------------------------------|

databricks_workspace provider​

The databricks_workspace provider is used for workspace-level operations, such as provisioning and managing clusters, dashboards, and workflow jobs (including delta live table pipelines).  Services include:  

stackql  >>show services in databricks_workspace;
|------------------------------|-----------------|-----------------|
|              id              |      name       |      title      |
|------------------------------|-----------------|-----------------|
| apps:v24.12.00279            | apps            | Apps            |
|------------------------------|-----------------|-----------------|
| cleanrooms:v24.12.00279      | cleanrooms      | Cleanrooms      |
|------------------------------|-----------------|-----------------|
| compute:v24.12.00279         | compute         | Compute         |
|------------------------------|-----------------|-----------------|
| dbsql:v24.12.00279           | dbsql           | Dbsql           |
|------------------------------|-----------------|-----------------|
| deltalivetables:v24.12.00279 | deltalivetables | Deltalivetables |
|------------------------------|-----------------|-----------------|
| deltasharing:v24.12.00279    | deltasharing    | Deltasharing    |
|------------------------------|-----------------|-----------------|
| filemanagement:v24.12.00279  | filemanagement  | Filemanagement  |
|------------------------------|-----------------|-----------------|
| iam:v24.12.00279             | iam             | Iam             |
|------------------------------|-----------------|-----------------|
| lakeview:v24.12.00279        | lakeview        | Lakeview        |
|------------------------------|-----------------|-----------------|
| machinelearning:v24.12.00279 | machinelearning | Machinelearning |
|------------------------------|-----------------|-----------------|
| marketplace:v24.12.00279     | marketplace     | Marketplace     |
|------------------------------|-----------------|-----------------|
| realtimeserving:v24.12.00279 | realtimeserving | Realtimeserving |
|------------------------------|-----------------|-----------------|
| repos:v24.12.00279           | repos           | Repos           |
|------------------------------|-----------------|-----------------|
| secrets:v24.12.00279         | secrets         | Secrets         |
|------------------------------|-----------------|-----------------|
| unitycatalog:v24.12.00279    | unitycatalog    | Unitycatalog    |
|------------------------------|-----------------|-----------------|
| vectorsearch:v24.12.00279    | vectorsearch    | Vectorsearch    |
|------------------------------|-----------------|-----------------|
| workflows:v24.12.00279       | workflows       | Workflows       |
|------------------------------|-----------------|-----------------|
| workspace:v24.12.00279       | workspace       | Workspace       |
|------------------------------|-----------------|-----------------|

An example query could be:

stackql  >>select
stackql  >>cluster_id,
stackql  >>aws_attributes,
stackql  >>node_type_id,
stackql  >>state
stackql  >>from
stackql  >>databricks_workspace.compute.clusters
stackql  >>where deployment_name = 'dbc-ddbc0f51-c9cf';
|----------------------|---------------------------------------------------------------------------------------------------------|--------------|------------|
|      cluster_id      |                                             aws_attributes                                              | node_type_id |   state    |
|----------------------|---------------------------------------------------------------------------------------------------------|--------------|------------|
| 1218-233957-q9v9oi86 | {"availability":"SPOT_WITH_FALLBACK","first_on_demand":1,"spot_bid_price_percent":100,"zone_id":"auto"} | m5d.large    | TERMINATED |
|----------------------|---------------------------------------------------------------------------------------------------------|--------------|------------|

To use either provider, set the following environment variables (either locally or as secrets in your preferred CI tool):

• DATABRICKS_ACCOUNT_ID - a uuid representing your Databricks account id, you can get this from the Databricks UI
• DATABRICKS_CLIENT_ID - obtained after creating a service principal through the Databricks UI
• DATABRICKS_CLIENT_SECRET - obtained after creating a service principal secret through the Databricks UI, using the "Generate Secret" function

These are the same variables that Terraform, the Databricks SDKs, and CLI use.  

stackql-deploy examples coming soon, stay tuned!  

⭐ us on GitHub and join our community!