Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. AWS
  3. API Docs
  4. glue
  5. Classifier
AWS v6.71.0 published on Friday, Mar 7, 2025 by Pulumi
pulumi/pulumi-aws

aws.glue.Classifier

Explore with Pulumi AI

aws logo
AWS v6.71.0 published on Friday, Mar 7, 2025 by Pulumi
pulumi/pulumi-aws

    Provides a Glue Classifier resource.

    NOTE: It is only valid to create one type of classifier (CSV, grok, JSON, or XML). Changing classifier types will recreate the classifier.

    Example Usage

    CSV Classifier

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

const example = new aws.glue.Classifier("example", {
    name: "example",
    csvClassifier: {
        allowSingleColumn: false,
        containsHeader: "PRESENT",
        delimiter: ",",
        disableValueTrimming: false,
        headers: [
            "example1",
            "example2",
        ],
        quoteSymbol: "'",
    },
});

    import pulumi
import pulumi_aws as aws

example = aws.glue.Classifier("example",
    name="example",
    csv_classifier={
        "allow_single_column": False,
        "contains_header": "PRESENT",
        "delimiter": ",",
        "disable_value_trimming": False,
        "headers": [
            "example1",
            "example2",
        ],
        "quote_symbol": "'",
    })

    package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := glue.NewClassifier(ctx, "example", &glue.ClassifierArgs{
			Name: pulumi.String("example"),
			CsvClassifier: &glue.ClassifierCsvClassifierArgs{
				AllowSingleColumn:    pulumi.Bool(false),
				ContainsHeader:       pulumi.String("PRESENT"),
				Delimiter:            pulumi.String(","),
				DisableValueTrimming: pulumi.Bool(false),
				Headers: pulumi.StringArray{
					pulumi.String("example1"),
					pulumi.String("example2"),
				},
				QuoteSymbol: pulumi.String("'"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Glue.Classifier("example", new()
    {
        Name = "example",
        CsvClassifier = new Aws.Glue.Inputs.ClassifierCsvClassifierArgs
        {
            AllowSingleColumn = false,
            ContainsHeader = "PRESENT",
            Delimiter = ",",
            DisableValueTrimming = false,
            Headers = new[]
            {
                "example1",
                "example2",
            },
            QuoteSymbol = "'",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.glue.Classifier;
import com.pulumi.aws.glue.ClassifierArgs;
import com.pulumi.aws.glue.inputs.ClassifierCsvClassifierArgs;
import java.util.List;
import java.util.ArrayList;
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 Classifier("example", ClassifierArgs.builder()
            .name("example")
            .csvClassifier(ClassifierCsvClassifierArgs.builder()
                .allowSingleColumn(false)
                .containsHeader("PRESENT")
                .delimiter(",")
                .disableValueTrimming(false)
                .headers(                
                    "example1",
                    "example2")
                .quoteSymbol("'")
                .build())
            .build());

    }
}

    resources:
  example:
    type: aws:glue:Classifier
    properties:
      name: example
      csvClassifier:
        allowSingleColumn: false
        containsHeader: PRESENT
        delimiter: ','
        disableValueTrimming: false
        headers:
          - example1
          - example2
        quoteSymbol: ''''

    Grok Classifier

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

const example = new aws.glue.Classifier("example", {
    name: "example",
    grokClassifier: {
        classification: "example",
        grokPattern: "example",
    },
});

    import pulumi
import pulumi_aws as aws

example = aws.glue.Classifier("example",
    name="example",
    grok_classifier={
        "classification": "example",
        "grok_pattern": "example",
    })

    package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := glue.NewClassifier(ctx, "example", &glue.ClassifierArgs{
			Name: pulumi.String("example"),
			GrokClassifier: &glue.ClassifierGrokClassifierArgs{
				Classification: pulumi.String("example"),
				GrokPattern:    pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Glue.Classifier("example", new()
    {
        Name = "example",
        GrokClassifier = new Aws.Glue.Inputs.ClassifierGrokClassifierArgs
        {
            Classification = "example",
            GrokPattern = "example",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.glue.Classifier;
import com.pulumi.aws.glue.ClassifierArgs;
import com.pulumi.aws.glue.inputs.ClassifierGrokClassifierArgs;
import java.util.List;
import java.util.ArrayList;
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 Classifier("example", ClassifierArgs.builder()
            .name("example")
            .grokClassifier(ClassifierGrokClassifierArgs.builder()
                .classification("example")
                .grokPattern("example")
                .build())
            .build());

    }
}

    resources:
  example:
    type: aws:glue:Classifier
    properties:
      name: example
      grokClassifier:
        classification: example
        grokPattern: example

    JSON Classifier

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

const example = new aws.glue.Classifier("example", {
    name: "example",
    jsonClassifier: {
        jsonPath: "example",
    },
});

    import pulumi
import pulumi_aws as aws

example = aws.glue.Classifier("example",
    name="example",
    json_classifier={
        "json_path": "example",
    })

    package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := glue.NewClassifier(ctx, "example", &glue.ClassifierArgs{
			Name: pulumi.String("example"),
			JsonClassifier: &glue.ClassifierJsonClassifierArgs{
				JsonPath: pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Glue.Classifier("example", new()
    {
        Name = "example",
        JsonClassifier = new Aws.Glue.Inputs.ClassifierJsonClassifierArgs
        {
            JsonPath = "example",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.glue.Classifier;
import com.pulumi.aws.glue.ClassifierArgs;
import com.pulumi.aws.glue.inputs.ClassifierJsonClassifierArgs;
import java.util.List;
import java.util.ArrayList;
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 Classifier("example", ClassifierArgs.builder()
            .name("example")
            .jsonClassifier(ClassifierJsonClassifierArgs.builder()
                .jsonPath("example")
                .build())
            .build());

    }
}

    resources:
  example:
    type: aws:glue:Classifier
    properties:
      name: example
      jsonClassifier:
        jsonPath: example

    XML Classifier

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

const example = new aws.glue.Classifier("example", {
    name: "example",
    xmlClassifier: {
        classification: "example",
        rowTag: "example",
    },
});

    import pulumi
import pulumi_aws as aws

example = aws.glue.Classifier("example",
    name="example",
    xml_classifier={
        "classification": "example",
        "row_tag": "example",
    })

    package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := glue.NewClassifier(ctx, "example", &glue.ClassifierArgs{
			Name: pulumi.String("example"),
			XmlClassifier: &glue.ClassifierXmlClassifierArgs{
				Classification: pulumi.String("example"),
				RowTag:         pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Glue.Classifier("example", new()
    {
        Name = "example",
        XmlClassifier = new Aws.Glue.Inputs.ClassifierXmlClassifierArgs
        {
            Classification = "example",
            RowTag = "example",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.glue.Classifier;
import com.pulumi.aws.glue.ClassifierArgs;
import com.pulumi.aws.glue.inputs.ClassifierXmlClassifierArgs;
import java.util.List;
import java.util.ArrayList;
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 Classifier("example", ClassifierArgs.builder()
            .name("example")
            .xmlClassifier(ClassifierXmlClassifierArgs.builder()
                .classification("example")
                .rowTag("example")
                .build())
            .build());

    }
}

    resources:
  example:
    type: aws:glue:Classifier
    properties:
      name: example
      xmlClassifier:
        classification: example
        rowTag: example

    Create Classifier Resource

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

    Constructor syntax

    new Classifier(name: string, args?: ClassifierArgs, opts?: CustomResourceOptions);
    @overload
def Classifier(resource_name: str,
               args: Optional[ClassifierArgs] = None,
               opts: Optional[ResourceOptions] = None)

@overload
def Classifier(resource_name: str,
               opts: Optional[ResourceOptions] = None,
               csv_classifier: Optional[ClassifierCsvClassifierArgs] = None,
               grok_classifier: Optional[ClassifierGrokClassifierArgs] = None,
               json_classifier: Optional[ClassifierJsonClassifierArgs] = None,
               name: Optional[str] = None,
               xml_classifier: Optional[ClassifierXmlClassifierArgs] = None)
    func NewClassifier(ctx *Context, name string, args *ClassifierArgs, opts ...ResourceOption) (*Classifier, error)
    public Classifier(string name, ClassifierArgs? args = null, CustomResourceOptions? opts = null)
    public Classifier(String name, ClassifierArgs args)
public Classifier(String name, ClassifierArgs args, CustomResourceOptions options)

    type: aws:glue:Classifier
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args ClassifierArgs
    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 ClassifierArgs
    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 ClassifierArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ClassifierArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ClassifierArgs
    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 classifierResource = new Aws.Glue.Classifier("classifierResource", new()
{
    CsvClassifier = new Aws.Glue.Inputs.ClassifierCsvClassifierArgs
    {
        AllowSingleColumn = false,
        ContainsHeader = "string",
        CustomDatatypeConfigured = false,
        CustomDatatypes = new[]
        {
            "string",
        },
        Delimiter = "string",
        DisableValueTrimming = false,
        Headers = new[]
        {
            "string",
        },
        QuoteSymbol = "string",
        Serde = "string",
    },
    GrokClassifier = new Aws.Glue.Inputs.ClassifierGrokClassifierArgs
    {
        Classification = "string",
        GrokPattern = "string",
        CustomPatterns = "string",
    },
    JsonClassifier = new Aws.Glue.Inputs.ClassifierJsonClassifierArgs
    {
        JsonPath = "string",
    },
    Name = "string",
    XmlClassifier = new Aws.Glue.Inputs.ClassifierXmlClassifierArgs
    {
        Classification = "string",
        RowTag = "string",
    },
});

    example, err := glue.NewClassifier(ctx, "classifierResource", &glue.ClassifierArgs{
	CsvClassifier: &glue.ClassifierCsvClassifierArgs{
		AllowSingleColumn:        pulumi.Bool(false),
		ContainsHeader:           pulumi.String("string"),
		CustomDatatypeConfigured: pulumi.Bool(false),
		CustomDatatypes: pulumi.StringArray{
			pulumi.String("string"),
		},
		Delimiter:            pulumi.String("string"),
		DisableValueTrimming: pulumi.Bool(false),
		Headers: pulumi.StringArray{
			pulumi.String("string"),
		},
		QuoteSymbol: pulumi.String("string"),
		Serde:       pulumi.String("string"),
	},
	GrokClassifier: &glue.ClassifierGrokClassifierArgs{
		Classification: pulumi.String("string"),
		GrokPattern:    pulumi.String("string"),
		CustomPatterns: pulumi.String("string"),
	},
	JsonClassifier: &glue.ClassifierJsonClassifierArgs{
		JsonPath: pulumi.String("string"),
	},
	Name: pulumi.String("string"),
	XmlClassifier: &glue.ClassifierXmlClassifierArgs{
		Classification: pulumi.String("string"),
		RowTag:         pulumi.String("string"),
	},
})

    var classifierResource = new Classifier("classifierResource", ClassifierArgs.builder()
    .csvClassifier(ClassifierCsvClassifierArgs.builder()
        .allowSingleColumn(false)
        .containsHeader("string")
        .customDatatypeConfigured(false)
        .customDatatypes("string")
        .delimiter("string")
        .disableValueTrimming(false)
        .headers("string")
        .quoteSymbol("string")
        .serde("string")
        .build())
    .grokClassifier(ClassifierGrokClassifierArgs.builder()
        .classification("string")
        .grokPattern("string")
        .customPatterns("string")
        .build())
    .jsonClassifier(ClassifierJsonClassifierArgs.builder()
        .jsonPath("string")
        .build())
    .name("string")
    .xmlClassifier(ClassifierXmlClassifierArgs.builder()
        .classification("string")
        .rowTag("string")
        .build())
    .build());

    classifier_resource = aws.glue.Classifier("classifierResource",
    csv_classifier={
        "allow_single_column": False,
        "contains_header": "string",
        "custom_datatype_configured": False,
        "custom_datatypes": ["string"],
        "delimiter": "string",
        "disable_value_trimming": False,
        "headers": ["string"],
        "quote_symbol": "string",
        "serde": "string",
    },
    grok_classifier={
        "classification": "string",
        "grok_pattern": "string",
        "custom_patterns": "string",
    },
    json_classifier={
        "json_path": "string",
    },
    name="string",
    xml_classifier={
        "classification": "string",
        "row_tag": "string",
    })

    const classifierResource = new aws.glue.Classifier("classifierResource", {
    csvClassifier: {
        allowSingleColumn: false,
        containsHeader: "string",
        customDatatypeConfigured: false,
        customDatatypes: ["string"],
        delimiter: "string",
        disableValueTrimming: false,
        headers: ["string"],
        quoteSymbol: "string",
        serde: "string",
    },
    grokClassifier: {
        classification: "string",
        grokPattern: "string",
        customPatterns: "string",
    },
    jsonClassifier: {
        jsonPath: "string",
    },
    name: "string",
    xmlClassifier: {
        classification: "string",
        rowTag: "string",
    },
});

    type: aws:glue:Classifier
properties:
    csvClassifier:
        allowSingleColumn: false
        containsHeader: string
        customDatatypeConfigured: false
        customDatatypes:
            - string
        delimiter: string
        disableValueTrimming: false
        headers:
            - string
        quoteSymbol: string
        serde: string
    grokClassifier:
        classification: string
        customPatterns: string
        grokPattern: string
    jsonClassifier:
        jsonPath: string
    name: string
    xmlClassifier:
        classification: string
        rowTag: string

    Classifier Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The Classifier resource accepts the following input properties:

    CsvClassifier ClassifierCsvClassifier
    A classifier for CSV content. Defined below.
    GrokClassifier ClassifierGrokClassifier
    A classifier that uses grok patterns. Defined below.
    JsonClassifier ClassifierJsonClassifier
    A classifier for JSON content. Defined below.
    Name string
    The name of the classifier.
    XmlClassifier ClassifierXmlClassifier
    A classifier for XML content. Defined below.
    CsvClassifier ClassifierCsvClassifierArgs
    A classifier for CSV content. Defined below.
    GrokClassifier ClassifierGrokClassifierArgs
    A classifier that uses grok patterns. Defined below.
    JsonClassifier ClassifierJsonClassifierArgs
    A classifier for JSON content. Defined below.
    Name string
    The name of the classifier.
    XmlClassifier ClassifierXmlClassifierArgs
    A classifier for XML content. Defined below.
    csvClassifier ClassifierCsvClassifier
    A classifier for CSV content. Defined below.
    grokClassifier ClassifierGrokClassifier
    A classifier that uses grok patterns. Defined below.
    jsonClassifier ClassifierJsonClassifier
    A classifier for JSON content. Defined below.
    name String
    The name of the classifier.
    xmlClassifier ClassifierXmlClassifier
    A classifier for XML content. Defined below.
    csvClassifier ClassifierCsvClassifier
    A classifier for CSV content. Defined below.
    grokClassifier ClassifierGrokClassifier
    A classifier that uses grok patterns. Defined below.
    jsonClassifier ClassifierJsonClassifier
    A classifier for JSON content. Defined below.
    name string
    The name of the classifier.
    xmlClassifier ClassifierXmlClassifier
    A classifier for XML content. Defined below.
    csv_classifier ClassifierCsvClassifierArgs
    A classifier for CSV content. Defined below.
    grok_classifier ClassifierGrokClassifierArgs
    A classifier that uses grok patterns. Defined below.
    json_classifier ClassifierJsonClassifierArgs
    A classifier for JSON content. Defined below.
    name str
    The name of the classifier.
    xml_classifier ClassifierXmlClassifierArgs
    A classifier for XML content. Defined below.
    csvClassifier Property Map
    A classifier for CSV content. Defined below.
    grokClassifier Property Map
    A classifier that uses grok patterns. Defined below.
    jsonClassifier Property Map
    A classifier for JSON content. Defined below.
    name String
    The name of the classifier.
    xmlClassifier Property Map
    A classifier for XML content. Defined below.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Classifier resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing Classifier Resource

    Get an existing Classifier resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ClassifierState, opts?: CustomResourceOptions): Classifier
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        csv_classifier: Optional[ClassifierCsvClassifierArgs] = None,
        grok_classifier: Optional[ClassifierGrokClassifierArgs] = None,
        json_classifier: Optional[ClassifierJsonClassifierArgs] = None,
        name: Optional[str] = None,
        xml_classifier: Optional[ClassifierXmlClassifierArgs] = None) -> Classifier
    func GetClassifier(ctx *Context, name string, id IDInput, state *ClassifierState, opts ...ResourceOption) (*Classifier, error)
    public static Classifier Get(string name, Input<string> id, ClassifierState? state, CustomResourceOptions? opts = null)
    public static Classifier get(String name, Output<String> id, ClassifierState state, CustomResourceOptions options)
    resources:  _:    type: aws:glue:Classifier    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    CsvClassifier ClassifierCsvClassifier
    A classifier for CSV content. Defined below.
    GrokClassifier ClassifierGrokClassifier
    A classifier that uses grok patterns. Defined below.
    JsonClassifier ClassifierJsonClassifier
    A classifier for JSON content. Defined below.
    Name string
    The name of the classifier.
    XmlClassifier ClassifierXmlClassifier
    A classifier for XML content. Defined below.
    CsvClassifier ClassifierCsvClassifierArgs
    A classifier for CSV content. Defined below.
    GrokClassifier ClassifierGrokClassifierArgs
    A classifier that uses grok patterns. Defined below.
    JsonClassifier ClassifierJsonClassifierArgs
    A classifier for JSON content. Defined below.
    Name string
    The name of the classifier.
    XmlClassifier ClassifierXmlClassifierArgs
    A classifier for XML content. Defined below.
    csvClassifier ClassifierCsvClassifier
    A classifier for CSV content. Defined below.
    grokClassifier ClassifierGrokClassifier
    A classifier that uses grok patterns. Defined below.
    jsonClassifier ClassifierJsonClassifier
    A classifier for JSON content. Defined below.
    name String
    The name of the classifier.
    xmlClassifier ClassifierXmlClassifier
    A classifier for XML content. Defined below.
    csvClassifier ClassifierCsvClassifier
    A classifier for CSV content. Defined below.
    grokClassifier ClassifierGrokClassifier
    A classifier that uses grok patterns. Defined below.
    jsonClassifier ClassifierJsonClassifier
    A classifier for JSON content. Defined below.
    name string
    The name of the classifier.
    xmlClassifier ClassifierXmlClassifier
    A classifier for XML content. Defined below.
    csv_classifier ClassifierCsvClassifierArgs
    A classifier for CSV content. Defined below.
    grok_classifier ClassifierGrokClassifierArgs
    A classifier that uses grok patterns. Defined below.
    json_classifier ClassifierJsonClassifierArgs
    A classifier for JSON content. Defined below.
    name str
    The name of the classifier.
    xml_classifier ClassifierXmlClassifierArgs
    A classifier for XML content. Defined below.
    csvClassifier Property Map
    A classifier for CSV content. Defined below.
    grokClassifier Property Map
    A classifier that uses grok patterns. Defined below.
    jsonClassifier Property Map
    A classifier for JSON content. Defined below.
    name String
    The name of the classifier.
    xmlClassifier Property Map
    A classifier for XML content. Defined below.

    Supporting Types

    ClassifierCsvClassifier, ClassifierCsvClassifierArgs

    AllowSingleColumn bool
    Enables the processing of files that contain only one column.
    ContainsHeader string
    Indicates whether the CSV file contains a header. This can be one of "ABSENT", "PRESENT", or "UNKNOWN".
    CustomDatatypeConfigured bool
    Enables the custom datatype to be configured.
    CustomDatatypes List<string>
    A list of supported custom datatypes. Valid values are BINARY, BOOLEAN, DATE, DECIMAL, DOUBLE, FLOAT, INT, LONG, SHORT, STRING, TIMESTAMP.
    Delimiter string
    The delimiter used in the CSV to separate columns.
    DisableValueTrimming bool
    Specifies whether to trim column values.
    Headers List<string>
    A list of strings representing column names.
    QuoteSymbol string
    A custom symbol to denote what combines content into a single column value. It must be different from the column delimiter.
    Serde string
    The SerDe for processing CSV. Valid values are OpenCSVSerDe, LazySimpleSerDe, None.
    AllowSingleColumn bool
    Enables the processing of files that contain only one column.
    ContainsHeader string
    Indicates whether the CSV file contains a header. This can be one of "ABSENT", "PRESENT", or "UNKNOWN".
    CustomDatatypeConfigured bool
    Enables the custom datatype to be configured.
    CustomDatatypes []string
    A list of supported custom datatypes. Valid values are BINARY, BOOLEAN, DATE, DECIMAL, DOUBLE, FLOAT, INT, LONG, SHORT, STRING, TIMESTAMP.
    Delimiter string
    The delimiter used in the CSV to separate columns.
    DisableValueTrimming bool
    Specifies whether to trim column values.
    Headers []string
    A list of strings representing column names.
    QuoteSymbol string
    A custom symbol to denote what combines content into a single column value. It must be different from the column delimiter.
    Serde string
    The SerDe for processing CSV. Valid values are OpenCSVSerDe, LazySimpleSerDe, None.
    allowSingleColumn Boolean
    Enables the processing of files that contain only one column.
    containsHeader String
    Indicates whether the CSV file contains a header. This can be one of "ABSENT", "PRESENT", or "UNKNOWN".
    customDatatypeConfigured Boolean
    Enables the custom datatype to be configured.
    customDatatypes List<String>
    A list of supported custom datatypes. Valid values are BINARY, BOOLEAN, DATE, DECIMAL, DOUBLE, FLOAT, INT, LONG, SHORT, STRING, TIMESTAMP.
    delimiter String
    The delimiter used in the CSV to separate columns.
    disableValueTrimming Boolean
    Specifies whether to trim column values.
    headers List<String>
    A list of strings representing column names.
    quoteSymbol String
    A custom symbol to denote what combines content into a single column value. It must be different from the column delimiter.
    serde String
    The SerDe for processing CSV. Valid values are OpenCSVSerDe, LazySimpleSerDe, None.
    allowSingleColumn boolean
    Enables the processing of files that contain only one column.
    containsHeader string
    Indicates whether the CSV file contains a header. This can be one of "ABSENT", "PRESENT", or "UNKNOWN".
    customDatatypeConfigured boolean
    Enables the custom datatype to be configured.
    customDatatypes string[]
    A list of supported custom datatypes. Valid values are BINARY, BOOLEAN, DATE, DECIMAL, DOUBLE, FLOAT, INT, LONG, SHORT, STRING, TIMESTAMP.
    delimiter string
    The delimiter used in the CSV to separate columns.
    disableValueTrimming boolean
    Specifies whether to trim column values.
    headers string[]
    A list of strings representing column names.
    quoteSymbol string
    A custom symbol to denote what combines content into a single column value. It must be different from the column delimiter.
    serde string
    The SerDe for processing CSV. Valid values are OpenCSVSerDe, LazySimpleSerDe, None.
    allow_single_column bool
    Enables the processing of files that contain only one column.
    contains_header str
    Indicates whether the CSV file contains a header. This can be one of "ABSENT", "PRESENT", or "UNKNOWN".
    custom_datatype_configured bool
    Enables the custom datatype to be configured.
    custom_datatypes Sequence[str]
    A list of supported custom datatypes. Valid values are BINARY, BOOLEAN, DATE, DECIMAL, DOUBLE, FLOAT, INT, LONG, SHORT, STRING, TIMESTAMP.
    delimiter str
    The delimiter used in the CSV to separate columns.
    disable_value_trimming bool
    Specifies whether to trim column values.
    headers Sequence[str]
    A list of strings representing column names.
    quote_symbol str
    A custom symbol to denote what combines content into a single column value. It must be different from the column delimiter.
    serde str
    The SerDe for processing CSV. Valid values are OpenCSVSerDe, LazySimpleSerDe, None.
    allowSingleColumn Boolean
    Enables the processing of files that contain only one column.
    containsHeader String
    Indicates whether the CSV file contains a header. This can be one of "ABSENT", "PRESENT", or "UNKNOWN".
    customDatatypeConfigured Boolean
    Enables the custom datatype to be configured.
    customDatatypes List<String>
    A list of supported custom datatypes. Valid values are BINARY, BOOLEAN, DATE, DECIMAL, DOUBLE, FLOAT, INT, LONG, SHORT, STRING, TIMESTAMP.
    delimiter String
    The delimiter used in the CSV to separate columns.
    disableValueTrimming Boolean
    Specifies whether to trim column values.
    headers List<String>
    A list of strings representing column names.
    quoteSymbol String
    A custom symbol to denote what combines content into a single column value. It must be different from the column delimiter.
    serde String
    The SerDe for processing CSV. Valid values are OpenCSVSerDe, LazySimpleSerDe, None.

    ClassifierGrokClassifier, ClassifierGrokClassifierArgs

    Classification string
    An identifier of the data format that the classifier matches, such as Twitter, JSON, Omniture logs, Amazon CloudWatch Logs, and so on.
    GrokPattern string
    The grok pattern used by this classifier.
    CustomPatterns string
    Custom grok patterns used by this classifier.
    Classification string
    An identifier of the data format that the classifier matches, such as Twitter, JSON, Omniture logs, Amazon CloudWatch Logs, and so on.
    GrokPattern string
    The grok pattern used by this classifier.
    CustomPatterns string
    Custom grok patterns used by this classifier.
    classification String
    An identifier of the data format that the classifier matches, such as Twitter, JSON, Omniture logs, Amazon CloudWatch Logs, and so on.
    grokPattern String
    The grok pattern used by this classifier.
    customPatterns String
    Custom grok patterns used by this classifier.
    classification string
    An identifier of the data format that the classifier matches, such as Twitter, JSON, Omniture logs, Amazon CloudWatch Logs, and so on.
    grokPattern string
    The grok pattern used by this classifier.
    customPatterns string
    Custom grok patterns used by this classifier.
    classification str
    An identifier of the data format that the classifier matches, such as Twitter, JSON, Omniture logs, Amazon CloudWatch Logs, and so on.
    grok_pattern str
    The grok pattern used by this classifier.
    custom_patterns str
    Custom grok patterns used by this classifier.
    classification String
    An identifier of the data format that the classifier matches, such as Twitter, JSON, Omniture logs, Amazon CloudWatch Logs, and so on.
    grokPattern String
    The grok pattern used by this classifier.
    customPatterns String
    Custom grok patterns used by this classifier.

    ClassifierJsonClassifier, ClassifierJsonClassifierArgs

    JsonPath string
    A JsonPath string defining the JSON data for the classifier to classify. AWS Glue supports a subset of JsonPath, as described in Writing JsonPath Custom Classifiers.
    JsonPath string
    A JsonPath string defining the JSON data for the classifier to classify. AWS Glue supports a subset of JsonPath, as described in Writing JsonPath Custom Classifiers.
    jsonPath String
    A JsonPath string defining the JSON data for the classifier to classify. AWS Glue supports a subset of JsonPath, as described in Writing JsonPath Custom Classifiers.
    jsonPath string
    A JsonPath string defining the JSON data for the classifier to classify. AWS Glue supports a subset of JsonPath, as described in Writing JsonPath Custom Classifiers.
    json_path str
    A JsonPath string defining the JSON data for the classifier to classify. AWS Glue supports a subset of JsonPath, as described in Writing JsonPath Custom Classifiers.
    jsonPath String
    A JsonPath string defining the JSON data for the classifier to classify. AWS Glue supports a subset of JsonPath, as described in Writing JsonPath Custom Classifiers.

    ClassifierXmlClassifier, ClassifierXmlClassifierArgs

    Classification string
    An identifier of the data format that the classifier matches.
    RowTag string
    The XML tag designating the element that contains each record in an XML document being parsed. Note that this cannot identify a self-closing element (closed by />). An empty row element that contains only attributes can be parsed as long as it ends with a closing tag (for example, <row item_a="A" item_b="B"></row> is okay, but <row item_a="A" item_b="B" /> is not).
    Classification string
    An identifier of the data format that the classifier matches.
    RowTag string
    The XML tag designating the element that contains each record in an XML document being parsed. Note that this cannot identify a self-closing element (closed by />). An empty row element that contains only attributes can be parsed as long as it ends with a closing tag (for example, <row item_a="A" item_b="B"></row> is okay, but <row item_a="A" item_b="B" /> is not).
    classification String
    An identifier of the data format that the classifier matches.
    rowTag String
    The XML tag designating the element that contains each record in an XML document being parsed. Note that this cannot identify a self-closing element (closed by />). An empty row element that contains only attributes can be parsed as long as it ends with a closing tag (for example, <row item_a="A" item_b="B"></row> is okay, but <row item_a="A" item_b="B" /> is not).
    classification string
    An identifier of the data format that the classifier matches.
    rowTag string
    The XML tag designating the element that contains each record in an XML document being parsed. Note that this cannot identify a self-closing element (closed by />). An empty row element that contains only attributes can be parsed as long as it ends with a closing tag (for example, <row item_a="A" item_b="B"></row> is okay, but <row item_a="A" item_b="B" /> is not).
    classification str
    An identifier of the data format that the classifier matches.
    row_tag str
    The XML tag designating the element that contains each record in an XML document being parsed. Note that this cannot identify a self-closing element (closed by />). An empty row element that contains only attributes can be parsed as long as it ends with a closing tag (for example, <row item_a="A" item_b="B"></row> is okay, but <row item_a="A" item_b="B" /> is not).
    classification String
    An identifier of the data format that the classifier matches.
    rowTag String
    The XML tag designating the element that contains each record in an XML document being parsed. Note that this cannot identify a self-closing element (closed by />). An empty row element that contains only attributes can be parsed as long as it ends with a closing tag (for example, <row item_a="A" item_b="B"></row> is okay, but <row item_a="A" item_b="B" /> is not).

    Import

    Using pulumi import, import Glue Classifiers using their name. For example:

    $ pulumi import aws:glue/classifier:Classifier MyClassifier MyClassifier

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    AWS Classic pulumi/pulumi-aws
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the aws Terraform Provider.
    aws logo
    AWS v6.71.0 published on Friday, Mar 7, 2025 by Pulumi
    pulumi/pulumi-aws