DataCatalog class

Provides an Athena data catalog.

More information about Athena and Athena data catalogs can be found in the Athena User Guide.

> Tip: for a more detailed explanation on the usage of parameters, see the DataCatalog API documentation

Example Usage

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

const example = new aws.athena.DataCatalog("example", {
    name: "athena-data-catalog",
    description: "Example Athena data catalog",
    type: "LAMBDA",
    parameters: {
        "function": "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function",
    },
    tags: {
        Name: "example-athena-data-catalog",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.athena.DataCatalog("example",
    name="athena-data-catalog",
    description="Example Athena data catalog",
    type="LAMBDA",
    parameters={
        "function": "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function",
    },
    tags={
        "Name": "example-athena-data-catalog",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Athena.DataCatalog("example", new()
    {
        Name = "athena-data-catalog",
        Description = "Example Athena data catalog",
        Type = "LAMBDA",
        Parameters =
        {
            { "function", "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function" },
        },
        Tags =
        {
            { "Name", "example-athena-data-catalog" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/athena"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := athena.NewDataCatalog(ctx, "example", &athena.DataCatalogArgs{
			Name:        pulumi.String("athena-data-catalog"),
			Description: pulumi.String("Example Athena data catalog"),
			Type:        pulumi.String("LAMBDA"),
			Parameters: pulumi.StringMap{
				"function": pulumi.String("arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function"),
			},
			Tags: pulumi.StringMap{
				"Name": pulumi.String("example-athena-data-catalog"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_athena_datacatalog" "example" {
  name        = "athena-data-catalog"
  description = "Example Athena data catalog"
  type        = "LAMBDA"
  parameters = {
    "function" = "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function"
  }
  tags = {
    "Name" = "example-athena-data-catalog"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.athena.DataCatalog;
import com.pulumi.aws.athena.DataCatalogArgs;
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 example = new DataCatalog("example", DataCatalogArgs.builder()
            .name("athena-data-catalog")
            .description("Example Athena data catalog")
            .type("LAMBDA")
            .parameters(Map.of("function", "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function"))
            .tags(Map.of("Name", "example-athena-data-catalog"))
            .build());

    }
}
resources:
  example:
    type: aws:athena:DataCatalog
    properties:
      name: athena-data-catalog
      description: Example Athena data catalog
      type: LAMBDA
      parameters:
        function: arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function
      tags:
        Name: example-athena-data-catalog

Hive based Data Catalog

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

const example = new aws.athena.DataCatalog("example", {
    name: "hive-data-catalog",
    description: "Hive based Data Catalog",
    type: "HIVE",
    parameters: {
        "metadata-function": "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.athena.DataCatalog("example",
    name="hive-data-catalog",
    description="Hive based Data Catalog",
    type="HIVE",
    parameters={
        "metadata-function": "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Athena.DataCatalog("example", new()
    {
        Name = "hive-data-catalog",
        Description = "Hive based Data Catalog",
        Type = "HIVE",
        Parameters =
        {
            { "metadata-function", "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/athena"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := athena.NewDataCatalog(ctx, "example", &athena.DataCatalogArgs{
			Name:        pulumi.String("hive-data-catalog"),
			Description: pulumi.String("Hive based Data Catalog"),
			Type:        pulumi.String("HIVE"),
			Parameters: pulumi.StringMap{
				"metadata-function": pulumi.String("arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_athena_datacatalog" "example" {
  name        = "hive-data-catalog"
  description = "Hive based Data Catalog"
  type        = "HIVE"
  parameters = {
    "metadata-function" = "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.athena.DataCatalog;
import com.pulumi.aws.athena.DataCatalogArgs;
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 example = new DataCatalog("example", DataCatalogArgs.builder()
            .name("hive-data-catalog")
            .description("Hive based Data Catalog")
            .type("HIVE")
            .parameters(Map.of("metadata-function", "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function"))
            .build());

    }
}
resources:
  example:
    type: aws:athena:DataCatalog
    properties:
      name: hive-data-catalog
      description: Hive based Data Catalog
      type: HIVE
      parameters:
        metadata-function: arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function

Glue based Data Catalog

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

const example = new aws.athena.DataCatalog("example", {
    name: "glue-data-catalog",
    description: "Glue based Data Catalog",
    type: "GLUE",
    parameters: {
        "catalog-id": "123456789012",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.athena.DataCatalog("example",
    name="glue-data-catalog",
    description="Glue based Data Catalog",
    type="GLUE",
    parameters={
        "catalog-id": "123456789012",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Athena.DataCatalog("example", new()
    {
        Name = "glue-data-catalog",
        Description = "Glue based Data Catalog",
        Type = "GLUE",
        Parameters =
        {
            { "catalog-id", "123456789012" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/athena"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := athena.NewDataCatalog(ctx, "example", &athena.DataCatalogArgs{
			Name:        pulumi.String("glue-data-catalog"),
			Description: pulumi.String("Glue based Data Catalog"),
			Type:        pulumi.String("GLUE"),
			Parameters: pulumi.StringMap{
				"catalog-id": pulumi.String("123456789012"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_athena_datacatalog" "example" {
  name        = "glue-data-catalog"
  description = "Glue based Data Catalog"
  type        = "GLUE"
  parameters = {
    "catalog-id" = "123456789012"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.athena.DataCatalog;
import com.pulumi.aws.athena.DataCatalogArgs;
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 example = new DataCatalog("example", DataCatalogArgs.builder()
            .name("glue-data-catalog")
            .description("Glue based Data Catalog")
            .type("GLUE")
            .parameters(Map.of("catalog-id", "123456789012"))
            .build());

    }
}
resources:
  example:
    type: aws:athena:DataCatalog
    properties:
      name: glue-data-catalog
      description: Glue based Data Catalog
      type: GLUE
      parameters:
        catalog-id: '123456789012'

Lambda based Data Catalog

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

const example = new aws.athena.DataCatalog("example", {
    name: "lambda-data-catalog",
    description: "Lambda based Data Catalog",
    type: "LAMBDA",
    parameters: {
        "metadata-function": "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-1",
        "record-function": "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-2",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.athena.DataCatalog("example",
    name="lambda-data-catalog",
    description="Lambda based Data Catalog",
    type="LAMBDA",
    parameters={
        "metadata-function": "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-1",
        "record-function": "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-2",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Athena.DataCatalog("example", new()
    {
        Name = "lambda-data-catalog",
        Description = "Lambda based Data Catalog",
        Type = "LAMBDA",
        Parameters =
        {
            { "metadata-function", "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-1" },
            { "record-function", "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-2" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/athena"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := athena.NewDataCatalog(ctx, "example", &athena.DataCatalogArgs{
			Name:        pulumi.String("lambda-data-catalog"),
			Description: pulumi.String("Lambda based Data Catalog"),
			Type:        pulumi.String("LAMBDA"),
			Parameters: pulumi.StringMap{
				"metadata-function": pulumi.String("arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-1"),
				"record-function":   pulumi.String("arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_athena_datacatalog" "example" {
  name        = "lambda-data-catalog"
  description = "Lambda based Data Catalog"
  type        = "LAMBDA"
  parameters = {
    "metadata-function" = "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-1"
    "record-function"   = "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-2"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.athena.DataCatalog;
import com.pulumi.aws.athena.DataCatalogArgs;
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 example = new DataCatalog("example", DataCatalogArgs.builder()
            .name("lambda-data-catalog")
            .description("Lambda based Data Catalog")
            .type("LAMBDA")
            .parameters(Map.ofEntries(
                Map.entry("metadata-function", "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-1"),
                Map.entry("record-function", "arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-2")
            ))
            .build());

    }
}
resources:
  example:
    type: aws:athena:DataCatalog
    properties:
      name: lambda-data-catalog
      description: Lambda based Data Catalog
      type: LAMBDA
      parameters:
        metadata-function: arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-1
        record-function: arn:aws:lambda:eu-central-1:123456789012:function:not-important-lambda-function-2

Import

Using pulumi import, import data catalogs using their name. For example:

$ pulumi import aws:athena/dataCatalog:DataCatalog example example-data-catalog

Constructors

DataCatalog(String name, {DataCatalogArgs? args, CustomResourceOptions? options})
Creates a new DataCatalog. name The Pulumi resource name. args Arguments used to configure this DataCatalog. The set of arguments for DataCatalog. options Resource options controlling this resource's behavior.
DataCatalog.reference(String urn)
Creates a typed reference to an existing DataCatalog resource.

Properties

arn ↔ Output<String>
ARN of the data catalog.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
description ↔ Output<String>
Description of the data catalog.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
name ↔ Output<String>
Name of the data catalog. The catalog name must be unique for the AWS account and can use a maximum of 128 alphanumeric, underscore, at sign, or hyphen characters.
latefinal
parameters ↔ Output<Map<String, String>>
Key value pairs that specifies the Lambda function or functions to use for the data catalog. The mapping used depends on the catalog type.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
tags ↔ Output<Map<String, String>?>
Map of tags to assign to the resource. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
type ↔ Output<String>
Type of data catalog: LAMBDA for a federated catalog, GLUE for AWS Glue Catalog, or HIVE for an external hive metastore.
latefinal
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {DataCatalogState? state, CustomResourceOptions? options}) → DataCatalog
Gets an existing DataCatalog resource's state with the given name and id.