1. Packages
  2. AWS Classic
  3. API Docs
  4. glue
  5. Classifier

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.40.0 published on Wednesday, Jun 12, 2024 by Pulumi

aws.glue.Classifier

Explore with Pulumi AI

aws logo

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.40.0 published on Wednesday, Jun 12, 2024 by Pulumi

    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=aws.glue.ClassifierCsvClassifierArgs(
            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=aws.glue.ClassifierGrokClassifierArgs(
            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=aws.glue.ClassifierJsonClassifierArgs(
            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=aws.glue.ClassifierXmlClassifierArgs(
            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.

    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=aws.glue.ClassifierCsvClassifierArgs(
            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=aws.glue.ClassifierGrokClassifierArgs(
            classification="string",
            grok_pattern="string",
            custom_patterns="string",
        ),
        json_classifier=aws.glue.ClassifierJsonClassifierArgs(
            json_path="string",
        ),
        name="string",
        xml_classifier=aws.glue.ClassifierXmlClassifierArgs(
            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

    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)
    Resource lookup is not supported in YAML
    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
    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
    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
    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
    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
    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

    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

    Try AWS Native preview for resources not in the classic version.

    AWS Classic v6.40.0 published on Wednesday, Jun 12, 2024 by Pulumi