PostgresDataApi

Databricks v1.100.0, Jul 21 26

Viewing docs for Databricks v1.100.0
published on Tuesday, Jul 21, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-databricks

Viewing docs for Databricks v1.100.0
published on Tuesday, Jul 21, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-databricks

Example Usage

Enable the Data API on a Database

Enable the Data API on a Lakebase database with default settings. The parent is the database resource name; the resulting Data API URL is exposed via status.url.

import * as pulumi from "@pulumi/pulumi";
import * as databricks from "@pulumi/databricks";

const _this = new databricks.PostgresProject("this", {
    projectId: "my-project",
    spec: {
        pgVersion: 17,
        displayName: "My Project",
    },
});
const main = new databricks.PostgresBranch("main", {
    branchId: "main",
    parent: _this.name,
    spec: {
        noExpiry: true,
    },
});
const appOwner = new databricks.PostgresRole("app_owner", {
    roleId: "app-owner",
    parent: main.name,
    spec: {
        postgresRole: "app_owner",
    },
});
const app = new databricks.PostgresDatabase("app", {
    databaseId: "app",
    parent: main.name,
    spec: {
        postgresDatabase: "app",
        role: appOwner.name,
    },
});
const appPostgresDataApi = new databricks.PostgresDataApi("app", {parent: app.name});
export const dataApiUrl = appPostgresDataApi.status.apply(status => status.url);

import pulumi
import pulumi_databricks as databricks

this = databricks.PostgresProject("this",
    project_id="my-project",
    spec={
        "pg_version": 17,
        "display_name": "My Project",
    })
main = databricks.PostgresBranch("main",
    branch_id="main",
    parent=this.name,
    spec={
        "no_expiry": True,
    })
app_owner = databricks.PostgresRole("app_owner",
    role_id="app-owner",
    parent=main.name,
    spec={
        "postgres_role": "app_owner",
    })
app = databricks.PostgresDatabase("app",
    database_id="app",
    parent=main.name,
    spec={
        "postgres_database": "app",
        "role": app_owner.name,
    })
app_postgres_data_api = databricks.PostgresDataApi("app", parent=app.name)
pulumi.export("dataApiUrl", app_postgres_data_api.status.url)

package main

import (
	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		this, err := databricks.NewPostgresProject(ctx, "this", &databricks.PostgresProjectArgs{
			ProjectId: pulumi.String("my-project"),
			Spec: &databricks.PostgresProjectSpecArgs{
				PgVersion:   pulumi.Int(17),
				DisplayName: pulumi.String("My Project"),
			},
		})
		if err != nil {
			return err
		}
		main, err := databricks.NewPostgresBranch(ctx, "main", &databricks.PostgresBranchArgs{
			BranchId: pulumi.String("main"),
			Parent:   this.Name,
			Spec: &databricks.PostgresBranchSpecArgs{
				NoExpiry: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		appOwner, err := databricks.NewPostgresRole(ctx, "app_owner", &databricks.PostgresRoleArgs{
			RoleId: pulumi.String("app-owner"),
			Parent: main.Name,
			Spec: &databricks.PostgresRoleSpecArgs{
				PostgresRole: pulumi.String("app_owner"),
			},
		})
		if err != nil {
			return err
		}
		app, err := databricks.NewPostgresDatabase(ctx, "app", &databricks.PostgresDatabaseArgs{
			DatabaseId: pulumi.String("app"),
			Parent:     main.Name,
			Spec: &databricks.PostgresDatabaseSpecArgs{
				PostgresDatabase: pulumi.String("app"),
				Role:             appOwner.Name,
			},
		})
		if err != nil {
			return err
		}
		appPostgresDataApi, err := databricks.NewPostgresDataApi(ctx, "app", &databricks.PostgresDataApiArgs{
			Parent: app.Name,
		})
		if err != nil {
			return err
		}
		ctx.Export("dataApiUrl", appPostgresDataApi.Status.ApplyT(func(status databricks.PostgresDataApiStatus) (*string, error) {
			return status.Url, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(() => 
{
    var @this = new Databricks.PostgresProject("this", new()
    {
        ProjectId = "my-project",
        Spec = new Databricks.Inputs.PostgresProjectSpecArgs
        {
            PgVersion = 17,
            DisplayName = "My Project",
        },
    });

    var main = new Databricks.PostgresBranch("main", new()
    {
        BranchId = "main",
        Parent = @this.Name,
        Spec = new Databricks.Inputs.PostgresBranchSpecArgs
        {
            NoExpiry = true,
        },
    });

    var appOwner = new Databricks.PostgresRole("app_owner", new()
    {
        RoleId = "app-owner",
        Parent = main.Name,
        Spec = new Databricks.Inputs.PostgresRoleSpecArgs
        {
            PostgresRole = "app_owner",
        },
    });

    var app = new Databricks.PostgresDatabase("app", new()
    {
        DatabaseId = "app",
        Parent = main.Name,
        Spec = new Databricks.Inputs.PostgresDatabaseSpecArgs
        {
            PostgresDatabase = "app",
            Role = appOwner.Name,
        },
    });

    var appPostgresDataApi = new Databricks.PostgresDataApi("app", new()
    {
        Parent = app.Name,
    });

    return new Dictionary<string, object?>
    {
        ["dataApiUrl"] = appPostgresDataApi.Status.Apply(status => status.Url),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.PostgresProject;
import com.pulumi.databricks.PostgresProjectArgs;
import com.pulumi.databricks.inputs.PostgresProjectSpecArgs;
import com.pulumi.databricks.PostgresBranch;
import com.pulumi.databricks.PostgresBranchArgs;
import com.pulumi.databricks.inputs.PostgresBranchSpecArgs;
import com.pulumi.databricks.PostgresRole;
import com.pulumi.databricks.PostgresRoleArgs;
import com.pulumi.databricks.inputs.PostgresRoleSpecArgs;
import com.pulumi.databricks.PostgresDatabase;
import com.pulumi.databricks.PostgresDatabaseArgs;
import com.pulumi.databricks.inputs.PostgresDatabaseSpecArgs;
import com.pulumi.databricks.PostgresDataApi;
import com.pulumi.databricks.PostgresDataApiArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var this_ = new PostgresProject("this", PostgresProjectArgs.builder()
            .projectId("my-project")
            .spec(PostgresProjectSpecArgs.builder()
                .pgVersion(17)
                .displayName("My Project")
                .build())
            .build());

        var main = new PostgresBranch("main", PostgresBranchArgs.builder()
            .branchId("main")
            .parent(this_.name())
            .spec(PostgresBranchSpecArgs.builder()
                .noExpiry(true)
                .build())
            .build());

        var appOwner = new PostgresRole("appOwner", PostgresRoleArgs.builder()
            .roleId("app-owner")
            .parent(main.name())
            .spec(PostgresRoleSpecArgs.builder()
                .postgresRole("app_owner")
                .build())
            .build());

        var app = new PostgresDatabase("app", PostgresDatabaseArgs.builder()
            .databaseId("app")
            .parent(main.name())
            .spec(PostgresDatabaseSpecArgs.builder()
                .postgresDatabase("app")
                .role(appOwner.name())
                .build())
            .build());

        var appPostgresDataApi = new PostgresDataApi("appPostgresDataApi", PostgresDataApiArgs.builder()
            .parent(app.name())
            .build());

        ctx.export("dataApiUrl", appPostgresDataApi.status().applyValue(_status -> _status.url()));
    }
}

resources:
  this:
    type: databricks:PostgresProject
    properties:
      projectId: my-project
      spec:
        pgVersion: 17
        displayName: My Project
  main:
    type: databricks:PostgresBranch
    properties:
      branchId: main
      parent: ${this.name}
      spec:
        noExpiry: true
  appOwner:
    type: databricks:PostgresRole
    name: app_owner
    properties:
      roleId: app-owner
      parent: ${main.name}
      spec:
        postgresRole: app_owner
  app:
    type: databricks:PostgresDatabase
    properties:
      databaseId: app
      parent: ${main.name}
      spec:
        postgresDatabase: app
        role: ${appOwner.name}
  appPostgresDataApi:
    type: databricks:PostgresDataApi
    name: app
    properties:
      parent: ${app.name}
outputs:
  dataApiUrl: ${appPostgresDataApi.status.url}

pulumi {
  required_providers {
    databricks = {
      source = "pulumi/databricks"
    }
  }
}

resource "databricks_postgresproject" "this" {
  project_id = "my-project"
  spec = {
    pg_version   = 17
    display_name = "My Project"
  }
}
resource "databricks_postgresbranch" "main" {
  branch_id = "main"
  parent    = databricks_postgresproject.this.name
  spec = {
    no_expiry = true
  }
}
resource "databricks_postgresrole" "app_owner" {
  role_id = "app-owner"
  parent  = databricks_postgresbranch.main.name
  spec = {
    postgres_role = "app_owner"
  }
}
resource "databricks_postgresdatabase" "app" {
  database_id = "app"
  parent      = databricks_postgresbranch.main.name
  spec = {
    postgres_database = "app"
    role              = databricks_postgresrole.app_owner.name
  }
}
resource "databricks_postgresdataapi" "app" {
  parent = databricks_postgresdatabase.app.name
}
output "dataApiUrl" {
  value = databricks_postgresdataapi.app.status.url
}

dbSchemas is application-managed, not infrastructure.

Enabling the Data API only stands up the PostgREST machinery (pgrst schema, authenticator role, preConfig function); the schemas exposed via dbSchemas must already exist in the database. They are application data, expected to be created by the application managing the database (SQL, sqitch, Flyway, etc.). Pulumi should not own them.

Custom PostgREST Settings

Tighten response size, restrict CORS, and configure the OpenAPI mode.

import * as pulumi from "@pulumi/pulumi";
import * as databricks from "@pulumi/databricks";

const app = new databricks.PostgresDataApi("app", {
    parent: appDatabricksPostgresDatabase.name,
    spec: {
        dbSchemas: ["public"],
        dbMaxRows: 1000,
        serverCorsAllowedOrigins: ["https://app.example.com"],
        serverTimingEnabled: true,
        openapiMode: "OPEN_API_MODE_IGNORE_PRIVILEGES",
    },
});

import pulumi
import pulumi_databricks as databricks

app = databricks.PostgresDataApi("app",
    parent=app_databricks_postgres_database["name"],
    spec={
        "db_schemas": ["public"],
        "db_max_rows": 1000,
        "server_cors_allowed_origins": ["https://app.example.com"],
        "server_timing_enabled": True,
        "openapi_mode": "OPEN_API_MODE_IGNORE_PRIVILEGES",
    })

package main

import (
	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databricks.NewPostgresDataApi(ctx, "app", &databricks.PostgresDataApiArgs{
			Parent: pulumi.Any(appDatabricksPostgresDatabase.Name),
			Spec: &databricks.PostgresDataApiSpecArgs{
				DbSchemas: pulumi.StringArray{
					pulumi.String("public"),
				},
				DbMaxRows: pulumi.Int(1000),
				ServerCorsAllowedOrigins: pulumi.StringArray{
					pulumi.String("https://app.example.com"),
				},
				ServerTimingEnabled: pulumi.Bool(true),
				OpenapiMode:         pulumi.String("OPEN_API_MODE_IGNORE_PRIVILEGES"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(() => 
{
    var app = new Databricks.PostgresDataApi("app", new()
    {
        Parent = appDatabricksPostgresDatabase.Name,
        Spec = new Databricks.Inputs.PostgresDataApiSpecArgs
        {
            DbSchemas = new[]
            {
                "public",
            },
            DbMaxRows = 1000,
            ServerCorsAllowedOrigins = new[]
            {
                "https://app.example.com",
            },
            ServerTimingEnabled = true,
            OpenapiMode = "OPEN_API_MODE_IGNORE_PRIVILEGES",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.PostgresDataApi;
import com.pulumi.databricks.PostgresDataApiArgs;
import com.pulumi.databricks.inputs.PostgresDataApiSpecArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var app = new PostgresDataApi("app", PostgresDataApiArgs.builder()
            .parent(appDatabricksPostgresDatabase.name())
            .spec(PostgresDataApiSpecArgs.builder()
                .dbSchemas("public")
                .dbMaxRows(1000)
                .serverCorsAllowedOrigins("https://app.example.com")
                .serverTimingEnabled(true)
                .openapiMode("OPEN_API_MODE_IGNORE_PRIVILEGES")
                .build())
            .build());

    }
}

resources:
  app:
    type: databricks:PostgresDataApi
    properties:
      parent: ${appDatabricksPostgresDatabase.name}
      spec:
        dbSchemas:
          - public
        dbMaxRows: 1000
        serverCorsAllowedOrigins:
          - https://app.example.com
        serverTimingEnabled: true
        openapiMode: OPEN_API_MODE_IGNORE_PRIVILEGES

pulumi {
  required_providers {
    databricks = {
      source = "pulumi/databricks"
    }
  }
}

resource "databricks_postgresdataapi" "app" {
  parent = appDatabricksPostgresDatabase.name
  spec = {
    db_schemas                  = ["public"]
    db_max_rows                 = 1000
    server_cors_allowed_origins = ["https://app.example.com"]
    server_timing_enabled       = true
    openapi_mode                = "OPEN_API_MODE_IGNORE_PRIVILEGES"
  }
}

Caveat: Clearing a Previously-Set Field

Removing a field from spec (or setting it to null) does not clear the value on the server with the typed schema today; the previous value remains in effect. To clear a field, taint the resource and re-apply, or use the API directly.

Refreshing the PostgREST schema cache

PostgREST caches the database’s schemas, roles, and functions in memory and only re-reads them on a refresh. Create/Update normally trigger this refresh automatically, but if it fails (for example a transient network blip), the database is configured but PostgREST can’t see the new schemas.

To re-trigger the refresh without changing any settings, call Update with no fields set in spec — the server treats this as a refresh-only request, re-reads the cache, and returns the unchanged state. Via the API directly:

curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/{p}/branches/{b}/databases/{d}/data-api?update_mask=spec" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"spec": {}}'

Create PostgresDataApi Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new PostgresDataApi(name: string, args: PostgresDataApiArgs, opts?: CustomResourceOptions);

@overload
def PostgresDataApi(resource_name: str,
                    args: PostgresDataApiArgs,
                    opts: Optional[ResourceOptions] = None)

@overload
def PostgresDataApi(resource_name: str,
                    opts: Optional[ResourceOptions] = None,
                    parent: Optional[str] = None,
                    provider_config: Optional[PostgresDataApiProviderConfigArgs] = None,
                    spec: Optional[PostgresDataApiSpecArgs] = None)

func NewPostgresDataApi(ctx *Context, name string, args PostgresDataApiArgs, opts ...ResourceOption) (*PostgresDataApi, error)

public PostgresDataApi(string name, PostgresDataApiArgs args, CustomResourceOptions? opts = null)

public PostgresDataApi(String name, PostgresDataApiArgs args)
public PostgresDataApi(String name, PostgresDataApiArgs args, CustomResourceOptions options)

type: databricks:PostgresDataApi
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

resource "databricks_postgres_data_api" "name" {
    # resource properties
}

Parameters

name string: The unique name of the resource.
args PostgresDataApiArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
args PostgresDataApiArgs: The arguments to resource properties.
opts ResourceOptions: Bag of options to control resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args PostgresDataApiArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args PostgresDataApiArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args PostgresDataApiArgs: The arguments to resource properties.
options CustomResourceOptions: Bag of options to control resource's behavior.

Constructor example

The following reference example uses placeholder values for all input properties.

var postgresDataApiResource = new Databricks.PostgresDataApi("postgresDataApiResource", new()
{
    Parent = "string",
    ProviderConfig = new Databricks.Inputs.PostgresDataApiProviderConfigArgs
    {
        WorkspaceId = "string",
    },
    Spec = new Databricks.Inputs.PostgresDataApiSpecArgs
    {
        DbAggregatesEnabled = false,
        DbExtraSearchPaths = new[]
        {
            "string",
        },
        DbMaxRows = 0,
        DbSchemas = new[]
        {
            "string",
        },
        JwtCacheMaxLifetime = "string",
        JwtRoleClaimKey = "string",
        OpenapiMode = "string",
        ServerCorsAllowedOrigins = new[]
        {
            "string",
        },
        ServerTimingEnabled = false,
    },
});

example, err := databricks.NewPostgresDataApi(ctx, "postgresDataApiResource", &databricks.PostgresDataApiArgs{
	Parent: pulumi.String("string"),
	ProviderConfig: &databricks.PostgresDataApiProviderConfigArgs{
		WorkspaceId: pulumi.String("string"),
	},
	Spec: &databricks.PostgresDataApiSpecArgs{
		DbAggregatesEnabled: pulumi.Bool(false),
		DbExtraSearchPaths: pulumi.StringArray{
			pulumi.String("string"),
		},
		DbMaxRows: pulumi.Int(0),
		DbSchemas: pulumi.StringArray{
			pulumi.String("string"),
		},
		JwtCacheMaxLifetime: pulumi.String("string"),
		JwtRoleClaimKey:     pulumi.String("string"),
		OpenapiMode:         pulumi.String("string"),
		ServerCorsAllowedOrigins: pulumi.StringArray{
			pulumi.String("string"),
		},
		ServerTimingEnabled: pulumi.Bool(false),
	},
})

resource "databricks_postgres_data_api" "postgresDataApiResource" {
  lifecycle {
    create_before_destroy = true
  }
  parent = "string"
  provider_config = {
    workspace_id = "string"
  }
  spec = {
    db_aggregates_enabled       = false
    db_extra_search_paths       = ["string"]
    db_max_rows                 = 0
    db_schemas                  = ["string"]
    jwt_cache_max_lifetime      = "string"
    jwt_role_claim_key          = "string"
    openapi_mode                = "string"
    server_cors_allowed_origins = ["string"]
    server_timing_enabled       = false
  }
}

var postgresDataApiResource = new PostgresDataApi("postgresDataApiResource", PostgresDataApiArgs.builder()
    .parent("string")
    .providerConfig(PostgresDataApiProviderConfigArgs.builder()
        .workspaceId("string")
        .build())
    .spec(PostgresDataApiSpecArgs.builder()
        .dbAggregatesEnabled(false)
        .dbExtraSearchPaths("string")
        .dbMaxRows(0)
        .dbSchemas("string")
        .jwtCacheMaxLifetime("string")
        .jwtRoleClaimKey("string")
        .openapiMode("string")
        .serverCorsAllowedOrigins("string")
        .serverTimingEnabled(false)
        .build())
    .build());

postgres_data_api_resource = databricks.PostgresDataApi("postgresDataApiResource",
    parent="string",
    provider_config={
        "workspace_id": "string",
    },
    spec={
        "db_aggregates_enabled": False,
        "db_extra_search_paths": ["string"],
        "db_max_rows": 0,
        "db_schemas": ["string"],
        "jwt_cache_max_lifetime": "string",
        "jwt_role_claim_key": "string",
        "openapi_mode": "string",
        "server_cors_allowed_origins": ["string"],
        "server_timing_enabled": False,
    })

const postgresDataApiResource = new databricks.PostgresDataApi("postgresDataApiResource", {
    parent: "string",
    providerConfig: {
        workspaceId: "string",
    },
    spec: {
        dbAggregatesEnabled: false,
        dbExtraSearchPaths: ["string"],
        dbMaxRows: 0,
        dbSchemas: ["string"],
        jwtCacheMaxLifetime: "string",
        jwtRoleClaimKey: "string",
        openapiMode: "string",
        serverCorsAllowedOrigins: ["string"],
        serverTimingEnabled: false,
    },
});

type: databricks:PostgresDataApi
properties:
    parent: string
    providerConfig:
        workspaceId: string
    spec:
        dbAggregatesEnabled: false
        dbExtraSearchPaths:
            - string
        dbMaxRows: 0
        dbSchemas:
            - string
        jwtCacheMaxLifetime: string
        jwtRoleClaimKey: string
        openapiMode: string
        serverCorsAllowedOrigins:
            - string
        serverTimingEnabled: false