1. Packages
  2. Opensearch Provider
  3. API Docs
  4. AuditConfig
opensearch 2.3.1 published on Monday, Apr 14, 2025 by opensearch-project

opensearch.AuditConfig

Explore with Pulumi AI

opensearch logo
opensearch 2.3.1 published on Monday, Apr 14, 2025 by opensearch-project

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as opensearch from "@pulumi/opensearch";
    
    const test = new opensearch.AuditConfig("test", {
        audit: {
            disabledRestCategories: [
                "GRANTED_PRIVILEGES",
                "AUTHENTICATED",
            ],
            disabledTransportCategories: [
                "GRANTED_PRIVILEGES",
                "AUTHENTICATED",
            ],
            enableRest: true,
            enableTransport: true,
            excludeSensitiveHeaders: true,
            ignoreRequests: [
                "SearchRequest",
                "indices:data/read/*",
                "/_cluster/health",
            ],
            ignoreUsers: ["dashboardserver"],
            logRequestBody: true,
            resolveBulkRequests: true,
            resolveIndices: true,
        },
        compliance: {
            enabled: true,
            externalConfig: false,
            internalConfig: true,
            readIgnoreUsers: ["read-ignore-1"],
            readMetadataOnly: true,
            readWatchedFields: [
                {
                    fields: [
                        "field-1",
                        "field-2",
                    ],
                    index: "read-index-1",
                },
                {
                    fields: ["field-3"],
                    index: "read-index-2",
                },
            ],
            writeIgnoreUsers: ["write-ignore-1"],
            writeLogDiffs: false,
            writeMetadataOnly: true,
            writeWatchedIndices: [
                "write-index-1",
                "write-index-2",
                "log-*",
                "*",
            ],
        },
        enabled: true,
    });
    
    import pulumi
    import pulumi_opensearch as opensearch
    
    test = opensearch.AuditConfig("test",
        audit={
            "disabled_rest_categories": [
                "GRANTED_PRIVILEGES",
                "AUTHENTICATED",
            ],
            "disabled_transport_categories": [
                "GRANTED_PRIVILEGES",
                "AUTHENTICATED",
            ],
            "enable_rest": True,
            "enable_transport": True,
            "exclude_sensitive_headers": True,
            "ignore_requests": [
                "SearchRequest",
                "indices:data/read/*",
                "/_cluster/health",
            ],
            "ignore_users": ["dashboardserver"],
            "log_request_body": True,
            "resolve_bulk_requests": True,
            "resolve_indices": True,
        },
        compliance={
            "enabled": True,
            "external_config": False,
            "internal_config": True,
            "read_ignore_users": ["read-ignore-1"],
            "read_metadata_only": True,
            "read_watched_fields": [
                {
                    "fields": [
                        "field-1",
                        "field-2",
                    ],
                    "index": "read-index-1",
                },
                {
                    "fields": ["field-3"],
                    "index": "read-index-2",
                },
            ],
            "write_ignore_users": ["write-ignore-1"],
            "write_log_diffs": False,
            "write_metadata_only": True,
            "write_watched_indices": [
                "write-index-1",
                "write-index-2",
                "log-*",
                "*",
            ],
        },
        enabled=True)
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opensearch/v2/opensearch"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := opensearch.NewAuditConfig(ctx, "test", &opensearch.AuditConfigArgs{
    			Audit: &opensearch.AuditConfigAuditArgs{
    				DisabledRestCategories: pulumi.StringArray{
    					pulumi.String("GRANTED_PRIVILEGES"),
    					pulumi.String("AUTHENTICATED"),
    				},
    				DisabledTransportCategories: pulumi.StringArray{
    					pulumi.String("GRANTED_PRIVILEGES"),
    					pulumi.String("AUTHENTICATED"),
    				},
    				EnableRest:              pulumi.Bool(true),
    				EnableTransport:         pulumi.Bool(true),
    				ExcludeSensitiveHeaders: pulumi.Bool(true),
    				IgnoreRequests: pulumi.StringArray{
    					pulumi.String("SearchRequest"),
    					pulumi.String("indices:data/read/*"),
    					pulumi.String("/_cluster/health"),
    				},
    				IgnoreUsers: pulumi.StringArray{
    					pulumi.String("dashboardserver"),
    				},
    				LogRequestBody:      pulumi.Bool(true),
    				ResolveBulkRequests: pulumi.Bool(true),
    				ResolveIndices:      pulumi.Bool(true),
    			},
    			Compliance: &opensearch.AuditConfigComplianceArgs{
    				Enabled:        pulumi.Bool(true),
    				ExternalConfig: pulumi.Bool(false),
    				InternalConfig: pulumi.Bool(true),
    				ReadIgnoreUsers: pulumi.StringArray{
    					pulumi.String("read-ignore-1"),
    				},
    				ReadMetadataOnly: pulumi.Bool(true),
    				ReadWatchedFields: opensearch.AuditConfigComplianceReadWatchedFieldArray{
    					&opensearch.AuditConfigComplianceReadWatchedFieldArgs{
    						Fields: pulumi.StringArray{
    							pulumi.String("field-1"),
    							pulumi.String("field-2"),
    						},
    						Index: pulumi.String("read-index-1"),
    					},
    					&opensearch.AuditConfigComplianceReadWatchedFieldArgs{
    						Fields: pulumi.StringArray{
    							pulumi.String("field-3"),
    						},
    						Index: pulumi.String("read-index-2"),
    					},
    				},
    				WriteIgnoreUsers: pulumi.StringArray{
    					pulumi.String("write-ignore-1"),
    				},
    				WriteLogDiffs:     pulumi.Bool(false),
    				WriteMetadataOnly: pulumi.Bool(true),
    				WriteWatchedIndices: pulumi.StringArray{
    					pulumi.String("write-index-1"),
    					pulumi.String("write-index-2"),
    					pulumi.String("log-*"),
    					pulumi.String("*"),
    				},
    			},
    			Enabled: pulumi.Bool(true),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Opensearch = Pulumi.Opensearch;
    
    return await Deployment.RunAsync(() => 
    {
        var test = new Opensearch.AuditConfig("test", new()
        {
            Audit = new Opensearch.Inputs.AuditConfigAuditArgs
            {
                DisabledRestCategories = new[]
                {
                    "GRANTED_PRIVILEGES",
                    "AUTHENTICATED",
                },
                DisabledTransportCategories = new[]
                {
                    "GRANTED_PRIVILEGES",
                    "AUTHENTICATED",
                },
                EnableRest = true,
                EnableTransport = true,
                ExcludeSensitiveHeaders = true,
                IgnoreRequests = new[]
                {
                    "SearchRequest",
                    "indices:data/read/*",
                    "/_cluster/health",
                },
                IgnoreUsers = new[]
                {
                    "dashboardserver",
                },
                LogRequestBody = true,
                ResolveBulkRequests = true,
                ResolveIndices = true,
            },
            Compliance = new Opensearch.Inputs.AuditConfigComplianceArgs
            {
                Enabled = true,
                ExternalConfig = false,
                InternalConfig = true,
                ReadIgnoreUsers = new[]
                {
                    "read-ignore-1",
                },
                ReadMetadataOnly = true,
                ReadWatchedFields = new[]
                {
                    new Opensearch.Inputs.AuditConfigComplianceReadWatchedFieldArgs
                    {
                        Fields = new[]
                        {
                            "field-1",
                            "field-2",
                        },
                        Index = "read-index-1",
                    },
                    new Opensearch.Inputs.AuditConfigComplianceReadWatchedFieldArgs
                    {
                        Fields = new[]
                        {
                            "field-3",
                        },
                        Index = "read-index-2",
                    },
                },
                WriteIgnoreUsers = new[]
                {
                    "write-ignore-1",
                },
                WriteLogDiffs = false,
                WriteMetadataOnly = true,
                WriteWatchedIndices = new[]
                {
                    "write-index-1",
                    "write-index-2",
                    "log-*",
                    "*",
                },
            },
            Enabled = true,
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.opensearch.AuditConfig;
    import com.pulumi.opensearch.AuditConfigArgs;
    import com.pulumi.opensearch.inputs.AuditConfigAuditArgs;
    import com.pulumi.opensearch.inputs.AuditConfigComplianceArgs;
    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 test = new AuditConfig("test", AuditConfigArgs.builder()
                .audit(AuditConfigAuditArgs.builder()
                    .disabledRestCategories(                
                        "GRANTED_PRIVILEGES",
                        "AUTHENTICATED")
                    .disabledTransportCategories(                
                        "GRANTED_PRIVILEGES",
                        "AUTHENTICATED")
                    .enableRest(true)
                    .enableTransport(true)
                    .excludeSensitiveHeaders(true)
                    .ignoreRequests(                
                        "SearchRequest",
                        "indices:data/read/*",
                        "/_cluster/health")
                    .ignoreUsers("dashboardserver")
                    .logRequestBody(true)
                    .resolveBulkRequests(true)
                    .resolveIndices(true)
                    .build())
                .compliance(AuditConfigComplianceArgs.builder()
                    .enabled(true)
                    .externalConfig(false)
                    .internalConfig(true)
                    .readIgnoreUsers("read-ignore-1")
                    .readMetadataOnly(true)
                    .readWatchedFields(                
                        AuditConfigComplianceReadWatchedFieldArgs.builder()
                            .fields(                        
                                "field-1",
                                "field-2")
                            .index("read-index-1")
                            .build(),
                        AuditConfigComplianceReadWatchedFieldArgs.builder()
                            .fields("field-3")
                            .index("read-index-2")
                            .build())
                    .writeIgnoreUsers("write-ignore-1")
                    .writeLogDiffs(false)
                    .writeMetadataOnly(true)
                    .writeWatchedIndices(                
                        "write-index-1",
                        "write-index-2",
                        "log-*",
                        "*")
                    .build())
                .enabled(true)
                .build());
    
        }
    }
    
    resources:
      test:
        type: opensearch:AuditConfig
        properties:
          audit:
            disabledRestCategories:
              - GRANTED_PRIVILEGES
              - AUTHENTICATED
            disabledTransportCategories:
              - GRANTED_PRIVILEGES
              - AUTHENTICATED
            enableRest: true
            enableTransport: true
            excludeSensitiveHeaders: true
            ignoreRequests:
              - SearchRequest
              - indices:data/read/*
              - /_cluster/health
            ignoreUsers:
              - dashboardserver
            logRequestBody: true
            resolveBulkRequests: true
            resolveIndices: true
          compliance:
            enabled: true
            externalConfig: false
            internalConfig: true
            readIgnoreUsers:
              - read-ignore-1
            readMetadataOnly: true
            readWatchedFields:
              - fields:
                  - field-1
                  - field-2
                index: read-index-1
              - fields:
                  - field-3
                index: read-index-2
            writeIgnoreUsers:
              - write-ignore-1
            writeLogDiffs: false
            writeMetadataOnly: true
            writeWatchedIndices:
              - write-index-1
              - write-index-2
              - log-*
              - '*'
          enabled: true
    

    Create AuditConfig Resource

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

    Constructor syntax

    new AuditConfig(name: string, args: AuditConfigArgs, opts?: CustomResourceOptions);
    @overload
    def AuditConfig(resource_name: str,
                    args: AuditConfigArgs,
                    opts: Optional[ResourceOptions] = None)
    
    @overload
    def AuditConfig(resource_name: str,
                    opts: Optional[ResourceOptions] = None,
                    enabled: Optional[bool] = None,
                    audit: Optional[AuditConfigAuditArgs] = None,
                    audit_config_id: Optional[str] = None,
                    compliance: Optional[AuditConfigComplianceArgs] = None)
    func NewAuditConfig(ctx *Context, name string, args AuditConfigArgs, opts ...ResourceOption) (*AuditConfig, error)
    public AuditConfig(string name, AuditConfigArgs args, CustomResourceOptions? opts = null)
    public AuditConfig(String name, AuditConfigArgs args)
    public AuditConfig(String name, AuditConfigArgs args, CustomResourceOptions options)
    
    type: opensearch:AuditConfig
    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 AuditConfigArgs
    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 AuditConfigArgs
    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 AuditConfigArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args AuditConfigArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args AuditConfigArgs
    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 auditConfigResource = new Opensearch.AuditConfig("auditConfigResource", new()
    {
        Enabled = false,
        Audit = new Opensearch.Inputs.AuditConfigAuditArgs
        {
            DisabledRestCategories = new[]
            {
                "string",
            },
            DisabledTransportCategories = new[]
            {
                "string",
            },
            EnableRest = false,
            EnableTransport = false,
            ExcludeSensitiveHeaders = false,
            IgnoreRequests = new[]
            {
                "string",
            },
            IgnoreUsers = new[]
            {
                "string",
            },
            LogRequestBody = false,
            ResolveBulkRequests = false,
            ResolveIndices = false,
        },
        AuditConfigId = "string",
        Compliance = new Opensearch.Inputs.AuditConfigComplianceArgs
        {
            Enabled = false,
            ExternalConfig = false,
            InternalConfig = false,
            ReadIgnoreUsers = new[]
            {
                "string",
            },
            ReadMetadataOnly = false,
            ReadWatchedFields = new[]
            {
                new Opensearch.Inputs.AuditConfigComplianceReadWatchedFieldArgs
                {
                    Fields = new[]
                    {
                        "string",
                    },
                    Index = "string",
                },
            },
            WriteIgnoreUsers = new[]
            {
                "string",
            },
            WriteLogDiffs = false,
            WriteMetadataOnly = false,
            WriteWatchedIndices = new[]
            {
                "string",
            },
        },
    });
    
    example, err := opensearch.NewAuditConfig(ctx, "auditConfigResource", &opensearch.AuditConfigArgs{
    	Enabled: pulumi.Bool(false),
    	Audit: &opensearch.AuditConfigAuditArgs{
    		DisabledRestCategories: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		DisabledTransportCategories: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		EnableRest:              pulumi.Bool(false),
    		EnableTransport:         pulumi.Bool(false),
    		ExcludeSensitiveHeaders: pulumi.Bool(false),
    		IgnoreRequests: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		IgnoreUsers: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		LogRequestBody:      pulumi.Bool(false),
    		ResolveBulkRequests: pulumi.Bool(false),
    		ResolveIndices:      pulumi.Bool(false),
    	},
    	AuditConfigId: pulumi.String("string"),
    	Compliance: &opensearch.AuditConfigComplianceArgs{
    		Enabled:        pulumi.Bool(false),
    		ExternalConfig: pulumi.Bool(false),
    		InternalConfig: pulumi.Bool(false),
    		ReadIgnoreUsers: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		ReadMetadataOnly: pulumi.Bool(false),
    		ReadWatchedFields: opensearch.AuditConfigComplianceReadWatchedFieldArray{
    			&opensearch.AuditConfigComplianceReadWatchedFieldArgs{
    				Fields: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				Index: pulumi.String("string"),
    			},
    		},
    		WriteIgnoreUsers: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		WriteLogDiffs:     pulumi.Bool(false),
    		WriteMetadataOnly: pulumi.Bool(false),
    		WriteWatchedIndices: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    	},
    })
    
    var auditConfigResource = new AuditConfig("auditConfigResource", AuditConfigArgs.builder()
        .enabled(false)
        .audit(AuditConfigAuditArgs.builder()
            .disabledRestCategories("string")
            .disabledTransportCategories("string")
            .enableRest(false)
            .enableTransport(false)
            .excludeSensitiveHeaders(false)
            .ignoreRequests("string")
            .ignoreUsers("string")
            .logRequestBody(false)
            .resolveBulkRequests(false)
            .resolveIndices(false)
            .build())
        .auditConfigId("string")
        .compliance(AuditConfigComplianceArgs.builder()
            .enabled(false)
            .externalConfig(false)
            .internalConfig(false)
            .readIgnoreUsers("string")
            .readMetadataOnly(false)
            .readWatchedFields(AuditConfigComplianceReadWatchedFieldArgs.builder()
                .fields("string")
                .index("string")
                .build())
            .writeIgnoreUsers("string")
            .writeLogDiffs(false)
            .writeMetadataOnly(false)
            .writeWatchedIndices("string")
            .build())
        .build());
    
    audit_config_resource = opensearch.AuditConfig("auditConfigResource",
        enabled=False,
        audit={
            "disabled_rest_categories": ["string"],
            "disabled_transport_categories": ["string"],
            "enable_rest": False,
            "enable_transport": False,
            "exclude_sensitive_headers": False,
            "ignore_requests": ["string"],
            "ignore_users": ["string"],
            "log_request_body": False,
            "resolve_bulk_requests": False,
            "resolve_indices": False,
        },
        audit_config_id="string",
        compliance={
            "enabled": False,
            "external_config": False,
            "internal_config": False,
            "read_ignore_users": ["string"],
            "read_metadata_only": False,
            "read_watched_fields": [{
                "fields": ["string"],
                "index": "string",
            }],
            "write_ignore_users": ["string"],
            "write_log_diffs": False,
            "write_metadata_only": False,
            "write_watched_indices": ["string"],
        })
    
    const auditConfigResource = new opensearch.AuditConfig("auditConfigResource", {
        enabled: false,
        audit: {
            disabledRestCategories: ["string"],
            disabledTransportCategories: ["string"],
            enableRest: false,
            enableTransport: false,
            excludeSensitiveHeaders: false,
            ignoreRequests: ["string"],
            ignoreUsers: ["string"],
            logRequestBody: false,
            resolveBulkRequests: false,
            resolveIndices: false,
        },
        auditConfigId: "string",
        compliance: {
            enabled: false,
            externalConfig: false,
            internalConfig: false,
            readIgnoreUsers: ["string"],
            readMetadataOnly: false,
            readWatchedFields: [{
                fields: ["string"],
                index: "string",
            }],
            writeIgnoreUsers: ["string"],
            writeLogDiffs: false,
            writeMetadataOnly: false,
            writeWatchedIndices: ["string"],
        },
    });
    
    type: opensearch:AuditConfig
    properties:
        audit:
            disabledRestCategories:
                - string
            disabledTransportCategories:
                - string
            enableRest: false
            enableTransport: false
            excludeSensitiveHeaders: false
            ignoreRequests:
                - string
            ignoreUsers:
                - string
            logRequestBody: false
            resolveBulkRequests: false
            resolveIndices: false
        auditConfigId: string
        compliance:
            enabled: false
            externalConfig: false
            internalConfig: false
            readIgnoreUsers:
                - string
            readMetadataOnly: false
            readWatchedFields:
                - fields:
                    - string
                  index: string
            writeIgnoreUsers:
                - string
            writeLogDiffs: false
            writeMetadataOnly: false
            writeWatchedIndices:
                - string
        enabled: false
    

    AuditConfig 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 AuditConfig resource accepts the following input properties:

    enabled Boolean
    audit Property Map
    auditConfigId String
    The ID of this resource.
    compliance Property Map

    Outputs

    All input properties are implicitly available as output properties. Additionally, the AuditConfig 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 AuditConfig Resource

    Get an existing AuditConfig 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?: AuditConfigState, opts?: CustomResourceOptions): AuditConfig
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            audit: Optional[AuditConfigAuditArgs] = None,
            audit_config_id: Optional[str] = None,
            compliance: Optional[AuditConfigComplianceArgs] = None,
            enabled: Optional[bool] = None) -> AuditConfig
    func GetAuditConfig(ctx *Context, name string, id IDInput, state *AuditConfigState, opts ...ResourceOption) (*AuditConfig, error)
    public static AuditConfig Get(string name, Input<string> id, AuditConfigState? state, CustomResourceOptions? opts = null)
    public static AuditConfig get(String name, Output<String> id, AuditConfigState state, CustomResourceOptions options)
    resources:  _:    type: opensearch:AuditConfig    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.

    Supporting Types

    AuditConfigAudit, AuditConfigAuditArgs

    AuditConfigCompliance, AuditConfigComplianceArgs

    AuditConfigComplianceReadWatchedField, AuditConfigComplianceReadWatchedFieldArgs

    Fields List<string>
    Index string
    Fields []string
    Index string
    fields List<String>
    index String
    fields string[]
    index string
    fields Sequence[str]
    index str
    fields List<String>
    index String

    Import

    Import by name

    $ pulumi import opensearch:index/auditConfig:AuditConfig test_config my-config
    

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

    Package Details

    Repository
    opensearch opensearch-project/terraform-provider-opensearch
    License
    Notes
    This Pulumi package is based on the opensearch Terraform Provider.
    opensearch logo
    opensearch 2.3.1 published on Monday, Apr 14, 2025 by opensearch-project