DataSource class

Resource for managing an AWS Kendra Data Source.

Example Usage

Basic Usage

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

const example = new aws.kendra.DataSource("example", {
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    description: "example",
    languageCode: "en",
    type: "CUSTOM",
    tags: {
        hello: "world",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    index_id=example_aws_kendra_index["id"],
    name="example",
    description="example",
    language_code="en",
    type="CUSTOM",
    tags={
        "hello": "world",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Description = "example",
        LanguageCode = "en",
        Type = "CUSTOM",
        Tags =
        {
            { "hello", "world" },
        },
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			IndexId:      pulumi.Any(exampleAwsKendraIndex.Id),
			Name:         pulumi.String("example"),
			Description:  pulumi.String("example"),
			LanguageCode: pulumi.String("en"),
			Type:         pulumi.String("CUSTOM"),
			Tags: pulumi.StringMap{
				"hello": pulumi.String("world"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  index_id      = exampleAwsKendraIndex.id
  name          = "example"
  description   = "example"
  language_code = "en"
  type          = "CUSTOM"
  tags = {
    "hello" = "world"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .description("example")
            .languageCode("en")
            .type("CUSTOM")
            .tags(Map.of("hello", "world"))
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      description: example
      languageCode: en
      type: CUSTOM
      tags:
        hello: world

S3 Connector

With Schedule

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        s3Configuration: {
            bucketName: exampleAwsS3Bucket.id,
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "S3",
    roleArn: exampleAwsIamRole.arn,
    schedule: "cron(9 10 1 * ? *)",
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "s3_configuration": {
            "bucket_name": example_aws_s3_bucket["id"],
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="S3",
    role_arn=example_aws_iam_role["arn"],
    schedule="cron(9 10 1 * ? *)")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            S3Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationS3ConfigurationArgs
            {
                BucketName = exampleAwsS3Bucket.Id,
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "S3",
        RoleArn = exampleAwsIamRole.Arn,
        Schedule = "cron(9 10 1 * ? *)",
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				S3Configuration: &kendra.DataSourceConfigurationS3ConfigurationArgs{
					BucketName: pulumi.Any(exampleAwsS3Bucket.Id),
				},
			},
			IndexId:  pulumi.Any(exampleAwsKendraIndex.Id),
			Name:     pulumi.String("example"),
			Type:     pulumi.String("S3"),
			RoleArn:  pulumi.Any(exampleAwsIamRole.Arn),
			Schedule: pulumi.String("cron(9 10 1 * ? *)"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    s3_configuration = {
      bucket_name = exampleAwsS3Bucket.id
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "S3"
  role_arn = exampleAwsIamRole.arn
  schedule = "cron(9 10 1 * ? *)"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationS3ConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .s3Configuration(DataSourceConfigurationS3ConfigurationArgs.builder()
                    .bucketName(exampleAwsS3Bucket.id())
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("S3")
            .roleArn(exampleAwsIamRole.arn())
            .schedule("cron(9 10 1 * ? *)")
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        s3Configuration:
          bucketName: ${exampleAwsS3Bucket.id}
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: S3
      roleArn: ${exampleAwsIamRole.arn}
      schedule: cron(9 10 1 * ? *)

With Access Control List

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        s3Configuration: {
            accessControlListConfiguration: {
                keyPath: `s3://${exampleAwsS3Bucket.id}/path-1`,
            },
            bucketName: exampleAwsS3Bucket.id,
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "S3",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "s3_configuration": {
            "access_control_list_configuration": {
                "key_path": f"s3://{example_aws_s3_bucket['id']}/path-1",
            },
            "bucket_name": example_aws_s3_bucket["id"],
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="S3",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            S3Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationS3ConfigurationArgs
            {
                AccessControlListConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationS3ConfigurationAccessControlListConfigurationArgs
                {
                    KeyPath = $"s3://{exampleAwsS3Bucket.Id}/path-1",
                },
                BucketName = exampleAwsS3Bucket.Id,
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "S3",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				S3Configuration: &kendra.DataSourceConfigurationS3ConfigurationArgs{
					AccessControlListConfiguration: &kendra.DataSourceConfigurationS3ConfigurationAccessControlListConfigurationArgs{
						KeyPath: pulumi.Sprintf("s3://%v/path-1", exampleAwsS3Bucket.Id),
					},
					BucketName: pulumi.Any(exampleAwsS3Bucket.Id),
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("S3"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    s3_configuration = {
      access_control_list_configuration = {
        key_path ="s3://${exampleAwsS3Bucket.id}/path-1"
      }
      bucket_name = exampleAwsS3Bucket.id
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "S3"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationS3ConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationS3ConfigurationAccessControlListConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .s3Configuration(DataSourceConfigurationS3ConfigurationArgs.builder()
                    .accessControlListConfiguration(DataSourceConfigurationS3ConfigurationAccessControlListConfigurationArgs.builder()
                        .keyPath(String.format("s3://%s/path-1", exampleAwsS3Bucket.id()))
                        .build())
                    .bucketName(exampleAwsS3Bucket.id())
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("S3")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        s3Configuration:
          accessControlListConfiguration:
            keyPath: s3://${exampleAwsS3Bucket.id}/path-1
          bucketName: ${exampleAwsS3Bucket.id}
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: S3
      roleArn: ${exampleAwsIamRole.arn}

With Documents Metadata Configuration

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        s3Configuration: {
            documentsMetadataConfiguration: {
                s3Prefix: "example",
            },
            bucketName: exampleAwsS3Bucket.id,
            exclusionPatterns: ["example"],
            inclusionPatterns: ["hello"],
            inclusionPrefixes: ["world"],
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "S3",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "s3_configuration": {
            "documents_metadata_configuration": {
                "s3_prefix": "example",
            },
            "bucket_name": example_aws_s3_bucket["id"],
            "exclusion_patterns": ["example"],
            "inclusion_patterns": ["hello"],
            "inclusion_prefixes": ["world"],
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="S3",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            S3Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationS3ConfigurationArgs
            {
                DocumentsMetadataConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationS3ConfigurationDocumentsMetadataConfigurationArgs
                {
                    S3Prefix = "example",
                },
                BucketName = exampleAwsS3Bucket.Id,
                ExclusionPatterns = new[]
                {
                    "example",
                },
                InclusionPatterns = new[]
                {
                    "hello",
                },
                InclusionPrefixes = new[]
                {
                    "world",
                },
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "S3",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				S3Configuration: &kendra.DataSourceConfigurationS3ConfigurationArgs{
					DocumentsMetadataConfiguration: &kendra.DataSourceConfigurationS3ConfigurationDocumentsMetadataConfigurationArgs{
						S3Prefix: pulumi.String("example"),
					},
					BucketName: pulumi.Any(exampleAwsS3Bucket.Id),
					ExclusionPatterns: pulumi.StringArray{
						pulumi.String("example"),
					},
					InclusionPatterns: pulumi.StringArray{
						pulumi.String("hello"),
					},
					InclusionPrefixes: pulumi.StringArray{
						pulumi.String("world"),
					},
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("S3"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    s3_configuration = {
      documents_metadata_configuration = {
        s3_prefix = "example"
      }
      bucket_name        = exampleAwsS3Bucket.id
      exclusion_patterns = ["example"]
      inclusion_patterns = ["hello"]
      inclusion_prefixes = ["world"]
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "S3"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationS3ConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationS3ConfigurationDocumentsMetadataConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .s3Configuration(DataSourceConfigurationS3ConfigurationArgs.builder()
                    .documentsMetadataConfiguration(DataSourceConfigurationS3ConfigurationDocumentsMetadataConfigurationArgs.builder()
                        .s3Prefix("example")
                        .build())
                    .bucketName(exampleAwsS3Bucket.id())
                    .exclusionPatterns("example")
                    .inclusionPatterns("hello")
                    .inclusionPrefixes("world")
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("S3")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        s3Configuration:
          documentsMetadataConfiguration:
            s3Prefix: example
          bucketName: ${exampleAwsS3Bucket.id}
          exclusionPatterns:
            - example
          inclusionPatterns:
            - hello
          inclusionPrefixes:
            - world
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: S3
      roleArn: ${exampleAwsIamRole.arn}

Web Crawler Connector

With Seed URLs

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        webCrawlerConfiguration: {
            urls: {
                seedUrlConfiguration: {
                    seedUrls: ["REPLACE_WITH_YOUR_URL"],
                },
            },
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "WEBCRAWLER",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "web_crawler_configuration": {
            "urls": {
                "seed_url_configuration": {
                    "seed_urls": ["REPLACE_WITH_YOUR_URL"],
                },
            },
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="WEBCRAWLER",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            WebCrawlerConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationArgs
            {
                Urls = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs
                {
                    SeedUrlConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs
                    {
                        SeedUrls = new[]
                        {
                            "REPLACE_WITH_YOUR_URL",
                        },
                    },
                },
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "WEBCRAWLER",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				WebCrawlerConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationArgs{
					Urls: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs{
						SeedUrlConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs{
							SeedUrls: pulumi.StringArray{
								pulumi.String("REPLACE_WITH_YOUR_URL"),
							},
						},
					},
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("WEBCRAWLER"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    web_crawler_configuration = {
      urls = {
        seed_url_configuration = {
          seed_urls = ["REPLACE_WITH_YOUR_URL"]
        }
      }
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "WEBCRAWLER"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .webCrawlerConfiguration(DataSourceConfigurationWebCrawlerConfigurationArgs.builder()
                    .urls(DataSourceConfigurationWebCrawlerConfigurationUrlsArgs.builder()
                        .seedUrlConfiguration(DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs.builder()
                            .seedUrls("REPLACE_WITH_YOUR_URL")
                            .build())
                        .build())
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("WEBCRAWLER")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        webCrawlerConfiguration:
          urls:
            seedUrlConfiguration:
              seedUrls:
                - REPLACE_WITH_YOUR_URL
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: WEBCRAWLER
      roleArn: ${exampleAwsIamRole.arn}

With Site Maps

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        webCrawlerConfiguration: {
            urls: {
                siteMapsConfiguration: {
                    siteMaps: ["REPLACE_WITH_YOUR_URL"],
                },
            },
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "WEBCRAWLER",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "web_crawler_configuration": {
            "urls": {
                "site_maps_configuration": {
                    "site_maps": ["REPLACE_WITH_YOUR_URL"],
                },
            },
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="WEBCRAWLER",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            WebCrawlerConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationArgs
            {
                Urls = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs
                {
                    SiteMapsConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSiteMapsConfigurationArgs
                    {
                        SiteMaps = new[]
                        {
                            "REPLACE_WITH_YOUR_URL",
                        },
                    },
                },
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "WEBCRAWLER",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				WebCrawlerConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationArgs{
					Urls: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs{
						SiteMapsConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsSiteMapsConfigurationArgs{
							SiteMaps: pulumi.StringArray{
								pulumi.String("REPLACE_WITH_YOUR_URL"),
							},
						},
					},
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("WEBCRAWLER"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    web_crawler_configuration = {
      urls = {
        site_maps_configuration = {
          site_maps = ["REPLACE_WITH_YOUR_URL"]
        }
      }
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "WEBCRAWLER"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSiteMapsConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .webCrawlerConfiguration(DataSourceConfigurationWebCrawlerConfigurationArgs.builder()
                    .urls(DataSourceConfigurationWebCrawlerConfigurationUrlsArgs.builder()
                        .siteMapsConfiguration(DataSourceConfigurationWebCrawlerConfigurationUrlsSiteMapsConfigurationArgs.builder()
                            .siteMaps("REPLACE_WITH_YOUR_URL")
                            .build())
                        .build())
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("WEBCRAWLER")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        webCrawlerConfiguration:
          urls:
            siteMapsConfiguration:
              siteMaps:
                - REPLACE_WITH_YOUR_URL
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: WEBCRAWLER
      roleArn: ${exampleAwsIamRole.arn}

With Web Crawler Mode

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        webCrawlerConfiguration: {
            urls: {
                seedUrlConfiguration: {
                    webCrawlerMode: "SUBDOMAINS",
                    seedUrls: ["REPLACE_WITH_YOUR_URL"],
                },
            },
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "WEBCRAWLER",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "web_crawler_configuration": {
            "urls": {
                "seed_url_configuration": {
                    "web_crawler_mode": "SUBDOMAINS",
                    "seed_urls": ["REPLACE_WITH_YOUR_URL"],
                },
            },
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="WEBCRAWLER",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            WebCrawlerConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationArgs
            {
                Urls = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs
                {
                    SeedUrlConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs
                    {
                        WebCrawlerMode = "SUBDOMAINS",
                        SeedUrls = new[]
                        {
                            "REPLACE_WITH_YOUR_URL",
                        },
                    },
                },
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "WEBCRAWLER",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				WebCrawlerConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationArgs{
					Urls: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs{
						SeedUrlConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs{
							WebCrawlerMode: pulumi.String("SUBDOMAINS"),
							SeedUrls: pulumi.StringArray{
								pulumi.String("REPLACE_WITH_YOUR_URL"),
							},
						},
					},
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("WEBCRAWLER"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    web_crawler_configuration = {
      urls = {
        seed_url_configuration = {
          web_crawler_mode = "SUBDOMAINS"
          seed_urls        = ["REPLACE_WITH_YOUR_URL"]
        }
      }
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "WEBCRAWLER"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .webCrawlerConfiguration(DataSourceConfigurationWebCrawlerConfigurationArgs.builder()
                    .urls(DataSourceConfigurationWebCrawlerConfigurationUrlsArgs.builder()
                        .seedUrlConfiguration(DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs.builder()
                            .webCrawlerMode("SUBDOMAINS")
                            .seedUrls("REPLACE_WITH_YOUR_URL")
                            .build())
                        .build())
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("WEBCRAWLER")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        webCrawlerConfiguration:
          urls:
            seedUrlConfiguration:
              webCrawlerMode: SUBDOMAINS
              seedUrls:
                - REPLACE_WITH_YOUR_URL
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: WEBCRAWLER
      roleArn: ${exampleAwsIamRole.arn}

With Authentication Configuration

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        webCrawlerConfiguration: {
            authenticationConfiguration: {
                basicAuthentications: [{
                    credentials: exampleAwsSecretsmanagerSecret.arn,
                    host: "a.example.com",
                    port: 443,
                }],
            },
            urls: {
                seedUrlConfiguration: {
                    seedUrls: ["REPLACE_WITH_YOUR_URL"],
                },
            },
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "WEBCRAWLER",
    roleArn: exampleAwsIamRole.arn,
}, {
    dependsOn: [exampleAwsSecretsmanagerSecretVersion],
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "web_crawler_configuration": {
            "authentication_configuration": {
                "basic_authentications": [{
                    "credentials": example_aws_secretsmanager_secret["arn"],
                    "host": "a.example.com",
                    "port": 443,
                }],
            },
            "urls": {
                "seed_url_configuration": {
                    "seed_urls": ["REPLACE_WITH_YOUR_URL"],
                },
            },
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="WEBCRAWLER",
    role_arn=example_aws_iam_role["arn"],
    opts = pulumi.ResourceOptions(depends_on=[example_aws_secretsmanager_secret_version]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            WebCrawlerConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationArgs
            {
                AuthenticationConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationArgs
                {
                    BasicAuthentications = new[]
                    {
                        new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationBasicAuthenticationArgs
                        {
                            Credentials = exampleAwsSecretsmanagerSecret.Arn,
                            Host = "a.example.com",
                            Port = 443,
                        },
                    },
                },
                Urls = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs
                {
                    SeedUrlConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs
                    {
                        SeedUrls = new[]
                        {
                            "REPLACE_WITH_YOUR_URL",
                        },
                    },
                },
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "WEBCRAWLER",
        RoleArn = exampleAwsIamRole.Arn,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleAwsSecretsmanagerSecretVersion,
        },
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				WebCrawlerConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationArgs{
					AuthenticationConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationArgs{
						BasicAuthentications: kendra.DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationBasicAuthenticationArray{
							&kendra.DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationBasicAuthenticationArgs{
								Credentials: pulumi.Any(exampleAwsSecretsmanagerSecret.Arn),
								Host:        pulumi.String("a.example.com"),
								Port:        pulumi.Int(443),
							},
						},
					},
					Urls: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs{
						SeedUrlConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs{
							SeedUrls: pulumi.StringArray{
								pulumi.String("REPLACE_WITH_YOUR_URL"),
							},
						},
					},
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("WEBCRAWLER"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAwsSecretsmanagerSecretVersion,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  depends_on = [exampleAwsSecretsmanagerSecretVersion]
  configuration = {
    web_crawler_configuration = {
      authentication_configuration = {
        basic_authentications = [{
          "credentials" = exampleAwsSecretsmanagerSecret.arn
          "host"        = "a.example.com"
          "port"        = "443"
        }]
      }
      urls = {
        seed_url_configuration = {
          seed_urls = ["REPLACE_WITH_YOUR_URL"]
        }
      }
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "WEBCRAWLER"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationBasicAuthenticationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .webCrawlerConfiguration(DataSourceConfigurationWebCrawlerConfigurationArgs.builder()
                    .authenticationConfiguration(DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationArgs.builder()
                        .basicAuthentications(DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationBasicAuthenticationArgs.builder()
                            .credentials(exampleAwsSecretsmanagerSecret.arn())
                            .host("a.example.com")
                            .port(443)
                            .build())
                        .build())
                    .urls(DataSourceConfigurationWebCrawlerConfigurationUrlsArgs.builder()
                        .seedUrlConfiguration(DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs.builder()
                            .seedUrls("REPLACE_WITH_YOUR_URL")
                            .build())
                        .build())
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("WEBCRAWLER")
            .roleArn(exampleAwsIamRole.arn())
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleAwsSecretsmanagerSecretVersion)
                .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        webCrawlerConfiguration:
          authenticationConfiguration:
            basicAuthentications:
              - credentials: ${exampleAwsSecretsmanagerSecret.arn}
                host: a.example.com
                port: '443'
          urls:
            seedUrlConfiguration:
              seedUrls:
                - REPLACE_WITH_YOUR_URL
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: WEBCRAWLER
      roleArn: ${exampleAwsIamRole.arn}
    options:
      dependsOn:
        - ${exampleAwsSecretsmanagerSecretVersion}

With Crawl Depth

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        webCrawlerConfiguration: {
            urls: {
                seedUrlConfiguration: {
                    seedUrls: ["REPLACE_WITH_YOUR_URL"],
                },
            },
            crawlDepth: 3,
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "WEBCRAWLER",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "web_crawler_configuration": {
            "urls": {
                "seed_url_configuration": {
                    "seed_urls": ["REPLACE_WITH_YOUR_URL"],
                },
            },
            "crawl_depth": 3,
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="WEBCRAWLER",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            WebCrawlerConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationArgs
            {
                Urls = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs
                {
                    SeedUrlConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs
                    {
                        SeedUrls = new[]
                        {
                            "REPLACE_WITH_YOUR_URL",
                        },
                    },
                },
                CrawlDepth = 3,
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "WEBCRAWLER",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				WebCrawlerConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationArgs{
					Urls: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs{
						SeedUrlConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs{
							SeedUrls: pulumi.StringArray{
								pulumi.String("REPLACE_WITH_YOUR_URL"),
							},
						},
					},
					CrawlDepth: pulumi.Int(3),
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("WEBCRAWLER"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    web_crawler_configuration = {
      urls = {
        seed_url_configuration = {
          seed_urls = ["REPLACE_WITH_YOUR_URL"]
        }
      }
      crawl_depth = 3
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "WEBCRAWLER"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .webCrawlerConfiguration(DataSourceConfigurationWebCrawlerConfigurationArgs.builder()
                    .urls(DataSourceConfigurationWebCrawlerConfigurationUrlsArgs.builder()
                        .seedUrlConfiguration(DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs.builder()
                            .seedUrls("REPLACE_WITH_YOUR_URL")
                            .build())
                        .build())
                    .crawlDepth(3)
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("WEBCRAWLER")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        webCrawlerConfiguration:
          urls:
            seedUrlConfiguration:
              seedUrls:
                - REPLACE_WITH_YOUR_URL
          crawlDepth: 3
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: WEBCRAWLER
      roleArn: ${exampleAwsIamRole.arn}
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.kendra.DataSource("example", {
    configuration: {
        webCrawlerConfiguration: {
            urls: {
                seedUrlConfiguration: {
                    seedUrls: ["REPLACE_WITH_YOUR_URL"],
                },
            },
            maxLinksPerPage: 100,
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "WEBCRAWLER",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "web_crawler_configuration": {
            "urls": {
                "seed_url_configuration": {
                    "seed_urls": ["REPLACE_WITH_YOUR_URL"],
                },
            },
            "max_links_per_page": 100,
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="WEBCRAWLER",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            WebCrawlerConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationArgs
            {
                Urls = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs
                {
                    SeedUrlConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs
                    {
                        SeedUrls = new[]
                        {
                            "REPLACE_WITH_YOUR_URL",
                        },
                    },
                },
                MaxLinksPerPage = 100,
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "WEBCRAWLER",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				WebCrawlerConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationArgs{
					Urls: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs{
						SeedUrlConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs{
							SeedUrls: pulumi.StringArray{
								pulumi.String("REPLACE_WITH_YOUR_URL"),
							},
						},
					},
					MaxLinksPerPage: pulumi.Int(100),
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("WEBCRAWLER"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    web_crawler_configuration = {
      urls = {
        seed_url_configuration = {
          seed_urls = ["REPLACE_WITH_YOUR_URL"]
        }
      }
      max_links_per_page = 100
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "WEBCRAWLER"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .webCrawlerConfiguration(DataSourceConfigurationWebCrawlerConfigurationArgs.builder()
                    .urls(DataSourceConfigurationWebCrawlerConfigurationUrlsArgs.builder()
                        .seedUrlConfiguration(DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs.builder()
                            .seedUrls("REPLACE_WITH_YOUR_URL")
                            .build())
                        .build())
                    .maxLinksPerPage(100)
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("WEBCRAWLER")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        webCrawlerConfiguration:
          urls:
            seedUrlConfiguration:
              seedUrls:
                - REPLACE_WITH_YOUR_URL
          maxLinksPerPage: 100
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: WEBCRAWLER
      roleArn: ${exampleAwsIamRole.arn}

With Max Urls Per Minute Crawl Rate

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        webCrawlerConfiguration: {
            urls: {
                seedUrlConfiguration: {
                    seedUrls: ["REPLACE_WITH_YOUR_URL"],
                },
            },
            maxUrlsPerMinuteCrawlRate: 300,
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "WEBCRAWLER",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "web_crawler_configuration": {
            "urls": {
                "seed_url_configuration": {
                    "seed_urls": ["REPLACE_WITH_YOUR_URL"],
                },
            },
            "max_urls_per_minute_crawl_rate": 300,
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="WEBCRAWLER",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            WebCrawlerConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationArgs
            {
                Urls = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs
                {
                    SeedUrlConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs
                    {
                        SeedUrls = new[]
                        {
                            "REPLACE_WITH_YOUR_URL",
                        },
                    },
                },
                MaxUrlsPerMinuteCrawlRate = 300,
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "WEBCRAWLER",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				WebCrawlerConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationArgs{
					Urls: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs{
						SeedUrlConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs{
							SeedUrls: pulumi.StringArray{
								pulumi.String("REPLACE_WITH_YOUR_URL"),
							},
						},
					},
					MaxUrlsPerMinuteCrawlRate: pulumi.Int(300),
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("WEBCRAWLER"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    web_crawler_configuration = {
      urls = {
        seed_url_configuration = {
          seed_urls = ["REPLACE_WITH_YOUR_URL"]
        }
      }
      max_urls_per_minute_crawl_rate = 300
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "WEBCRAWLER"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .webCrawlerConfiguration(DataSourceConfigurationWebCrawlerConfigurationArgs.builder()
                    .urls(DataSourceConfigurationWebCrawlerConfigurationUrlsArgs.builder()
                        .seedUrlConfiguration(DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs.builder()
                            .seedUrls("REPLACE_WITH_YOUR_URL")
                            .build())
                        .build())
                    .maxUrlsPerMinuteCrawlRate(300)
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("WEBCRAWLER")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        webCrawlerConfiguration:
          urls:
            seedUrlConfiguration:
              seedUrls:
                - REPLACE_WITH_YOUR_URL
          maxUrlsPerMinuteCrawlRate: 300
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: WEBCRAWLER
      roleArn: ${exampleAwsIamRole.arn}

With Proxy Configuration

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        webCrawlerConfiguration: {
            proxyConfiguration: {
                credentials: exampleAwsSecretsmanagerSecret.arn,
                host: "a.example.com",
                port: 443,
            },
            urls: {
                seedUrlConfiguration: {
                    seedUrls: ["REPLACE_WITH_YOUR_URL"],
                },
            },
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "WEBCRAWLER",
    roleArn: exampleAwsIamRole.arn,
}, {
    dependsOn: [exampleAwsSecretsmanagerSecretVersion],
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "web_crawler_configuration": {
            "proxy_configuration": {
                "credentials": example_aws_secretsmanager_secret["arn"],
                "host": "a.example.com",
                "port": 443,
            },
            "urls": {
                "seed_url_configuration": {
                    "seed_urls": ["REPLACE_WITH_YOUR_URL"],
                },
            },
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="WEBCRAWLER",
    role_arn=example_aws_iam_role["arn"],
    opts = pulumi.ResourceOptions(depends_on=[example_aws_secretsmanager_secret_version]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            WebCrawlerConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationArgs
            {
                ProxyConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationProxyConfigurationArgs
                {
                    Credentials = exampleAwsSecretsmanagerSecret.Arn,
                    Host = "a.example.com",
                    Port = 443,
                },
                Urls = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs
                {
                    SeedUrlConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs
                    {
                        SeedUrls = new[]
                        {
                            "REPLACE_WITH_YOUR_URL",
                        },
                    },
                },
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "WEBCRAWLER",
        RoleArn = exampleAwsIamRole.Arn,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleAwsSecretsmanagerSecretVersion,
        },
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				WebCrawlerConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationArgs{
					ProxyConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationProxyConfigurationArgs{
						Credentials: pulumi.Any(exampleAwsSecretsmanagerSecret.Arn),
						Host:        pulumi.String("a.example.com"),
						Port:        pulumi.Int(443),
					},
					Urls: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs{
						SeedUrlConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs{
							SeedUrls: pulumi.StringArray{
								pulumi.String("REPLACE_WITH_YOUR_URL"),
							},
						},
					},
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("WEBCRAWLER"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAwsSecretsmanagerSecretVersion,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  depends_on = [exampleAwsSecretsmanagerSecretVersion]
  configuration = {
    web_crawler_configuration = {
      proxy_configuration = {
        credentials = exampleAwsSecretsmanagerSecret.arn
        host        = "a.example.com"
        port        = "443"
      }
      urls = {
        seed_url_configuration = {
          seed_urls = ["REPLACE_WITH_YOUR_URL"]
        }
      }
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "WEBCRAWLER"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationProxyConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .webCrawlerConfiguration(DataSourceConfigurationWebCrawlerConfigurationArgs.builder()
                    .proxyConfiguration(DataSourceConfigurationWebCrawlerConfigurationProxyConfigurationArgs.builder()
                        .credentials(exampleAwsSecretsmanagerSecret.arn())
                        .host("a.example.com")
                        .port(443)
                        .build())
                    .urls(DataSourceConfigurationWebCrawlerConfigurationUrlsArgs.builder()
                        .seedUrlConfiguration(DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs.builder()
                            .seedUrls("REPLACE_WITH_YOUR_URL")
                            .build())
                        .build())
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("WEBCRAWLER")
            .roleArn(exampleAwsIamRole.arn())
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleAwsSecretsmanagerSecretVersion)
                .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        webCrawlerConfiguration:
          proxyConfiguration:
            credentials: ${exampleAwsSecretsmanagerSecret.arn}
            host: a.example.com
            port: '443'
          urls:
            seedUrlConfiguration:
              seedUrls:
                - REPLACE_WITH_YOUR_URL
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: WEBCRAWLER
      roleArn: ${exampleAwsIamRole.arn}
    options:
      dependsOn:
        - ${exampleAwsSecretsmanagerSecretVersion}

With URL Exclusion and Inclusion Patterns

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        webCrawlerConfiguration: {
            urls: {
                seedUrlConfiguration: {
                    seedUrls: ["REPLACE_WITH_YOUR_URL"],
                },
            },
            urlExclusionPatterns: ["example"],
            urlInclusionPatterns: ["hello"],
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "WEBCRAWLER",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "web_crawler_configuration": {
            "urls": {
                "seed_url_configuration": {
                    "seed_urls": ["REPLACE_WITH_YOUR_URL"],
                },
            },
            "url_exclusion_patterns": ["example"],
            "url_inclusion_patterns": ["hello"],
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="WEBCRAWLER",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            WebCrawlerConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationArgs
            {
                Urls = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs
                {
                    SeedUrlConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs
                    {
                        SeedUrls = new[]
                        {
                            "REPLACE_WITH_YOUR_URL",
                        },
                    },
                },
                UrlExclusionPatterns = new[]
                {
                    "example",
                },
                UrlInclusionPatterns = new[]
                {
                    "hello",
                },
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "WEBCRAWLER",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				WebCrawlerConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationArgs{
					Urls: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs{
						SeedUrlConfiguration: &kendra.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs{
							SeedUrls: pulumi.StringArray{
								pulumi.String("REPLACE_WITH_YOUR_URL"),
							},
						},
					},
					UrlExclusionPatterns: pulumi.StringArray{
						pulumi.String("example"),
					},
					UrlInclusionPatterns: pulumi.StringArray{
						pulumi.String("hello"),
					},
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("WEBCRAWLER"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    web_crawler_configuration = {
      urls = {
        seed_url_configuration = {
          seed_urls = ["REPLACE_WITH_YOUR_URL"]
        }
      }
      url_exclusion_patterns = ["example"]
      url_inclusion_patterns = ["hello"]
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "WEBCRAWLER"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .webCrawlerConfiguration(DataSourceConfigurationWebCrawlerConfigurationArgs.builder()
                    .urls(DataSourceConfigurationWebCrawlerConfigurationUrlsArgs.builder()
                        .seedUrlConfiguration(DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs.builder()
                            .seedUrls("REPLACE_WITH_YOUR_URL")
                            .build())
                        .build())
                    .urlExclusionPatterns("example")
                    .urlInclusionPatterns("hello")
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("WEBCRAWLER")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        webCrawlerConfiguration:
          urls:
            seedUrlConfiguration:
              seedUrls:
                - REPLACE_WITH_YOUR_URL
          urlExclusionPatterns:
            - example
          urlInclusionPatterns:
            - hello
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: WEBCRAWLER
      roleArn: ${exampleAwsIamRole.arn}

With WEBCRAWLERV2 Template

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

const example = new aws.kendra.DataSource("example", {
    configuration: {
        templateConfiguration: {
            template: JSON.stringify({
                connectionConfiguration: {
                    repositoryEndpointMetadata: {
                        seedUrlConnections: [{
                            seedUrl: "https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/kendra_index",
                        }],
                    },
                },
                additionalProperties: {
                    inclusionURLIndexPatterns: ["https:\\/\\/registry[.]terraform[.]io\\/providers\\/hashicorp\\/aws\\/latest\\/docs\\/resources\\/kendra_index"],
                },
                version: "1.0.0",
                syncMode: "FULL_CRAWL",
                type: "WEBCRAWLERV2",
            }),
        },
    },
    indexId: exampleAwsKendraIndex.id,
    name: "example",
    type: "TEMPLATE",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import json
import pulumi_aws as aws

example = aws.kendra.DataSource("example",
    configuration={
        "template_configuration": {
            "template": json.dumps({
                "connectionConfiguration": {
                    "repositoryEndpointMetadata": {
                        "seedUrlConnections": [{
                            "seedUrl": "https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/kendra_index",
                        }],
                    },
                },
                "additionalProperties": {
                    "inclusionURLIndexPatterns": ["https:\\/\\/registry[.]terraform[.]io\\/providers\\/hashicorp\\/aws\\/latest\\/docs\\/resources\\/kendra_index"],
                },
                "version": "1.0.0",
                "syncMode": "FULL_CRAWL",
                "type": "WEBCRAWLERV2",
            }),
        },
    },
    index_id=example_aws_kendra_index["id"],
    name="example",
    type="TEMPLATE",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kendra.DataSource("example", new()
    {
        Configuration = new Aws.Kendra.Inputs.DataSourceConfigurationArgs
        {
            TemplateConfiguration = new Aws.Kendra.Inputs.DataSourceConfigurationTemplateConfigurationArgs
            {
                Template = JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["connectionConfiguration"] = new Dictionary<string, object?>
                    {
                        ["repositoryEndpointMetadata"] = new Dictionary<string, object?>
                        {
                            ["seedUrlConnections"] = new[]
                            {
                                new Dictionary<string, object?>
                                {
                                    ["seedUrl"] = "https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/kendra_index",
                                },
                            },
                        },
                    },
                    ["additionalProperties"] = new Dictionary<string, object?>
                    {
                        ["inclusionURLIndexPatterns"] = new[]
                        {
                            "https:\\/\\/registry[.]terraform[.]io\\/providers\\/hashicorp\\/aws\\/latest\\/docs\\/resources\\/kendra_index",
                        },
                    },
                    ["version"] = "1.0.0",
                    ["syncMode"] = "FULL_CRAWL",
                    ["type"] = "WEBCRAWLERV2",
                }),
            },
        },
        IndexId = exampleAwsKendraIndex.Id,
        Name = "example",
        Type = "TEMPLATE",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/kendra"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"connectionConfiguration": map[string]map[string][]map[string]string{
				"repositoryEndpointMetadata": map[string][]map[string]string{
					"seedUrlConnections": []map[string]string{
						{
							"seedUrl": "https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/kendra_index",
						},
					},
				},
			},
			"additionalProperties": map[string][]string{
				"inclusionURLIndexPatterns": []string{
					"https:\\/\\/registry[.]terraform[.]io\\/providers\\/hashicorp\\/aws\\/latest\\/docs\\/resources\\/kendra_index",
				},
			},
			"version":  "1.0.0",
			"syncMode": "FULL_CRAWL",
			"type":     "WEBCRAWLERV2",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = kendra.NewDataSource(ctx, "example", &kendra.DataSourceArgs{
			Configuration: &kendra.DataSourceConfigurationArgs{
				TemplateConfiguration: &kendra.DataSourceConfigurationTemplateConfigurationArgs{
					Template: pulumi.String(json0),
				},
			},
			IndexId: pulumi.Any(exampleAwsKendraIndex.Id),
			Name:    pulumi.String("example"),
			Type:    pulumi.String("TEMPLATE"),
			RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_kendra_datasource" "example" {
  configuration = {
    template_configuration = {
      template = jsonencode({
        "connectionConfiguration" = {
          "repositoryEndpointMetadata" = {
            "seedUrlConnections" = [{
              "seedUrl" = "https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/kendra_index"
            }]
          }
        }
        "additionalProperties" = {
          "inclusionURLIndexPatterns" = ["https:\\/\\/registry[.]terraform[.]io\\/providers\\/hashicorp\\/aws\\/latest\\/docs\\/resources\\/kendra_index"]
        }
        "version"  = "1.0.0"
        "syncMode" = "FULL_CRAWL"
        "type"     = "WEBCRAWLERV2"
      })
    }
  }
  index_id = exampleAwsKendraIndex.id
  name     = "example"
  type     = "TEMPLATE"
  role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kendra.DataSource;
import com.pulumi.aws.kendra.DataSourceArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationArgs;
import com.pulumi.aws.kendra.inputs.DataSourceConfigurationTemplateConfigurationArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new DataSource("example", DataSourceArgs.builder()
            .configuration(DataSourceConfigurationArgs.builder()
                .templateConfiguration(DataSourceConfigurationTemplateConfigurationArgs.builder()
                    .template(serializeJson(
                        jsonObject(
                            jsonProperty("connectionConfiguration", jsonObject(
                                jsonProperty("repositoryEndpointMetadata", jsonObject(
                                    jsonProperty("seedUrlConnections", jsonArray(jsonObject(
                                        jsonProperty("seedUrl", "https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/kendra_index")
                                    )))
                                ))
                            )),
                            jsonProperty("additionalProperties", jsonObject(
                                jsonProperty("inclusionURLIndexPatterns", jsonArray("https:\\/\\/registry[.]terraform[.]io\\/providers\\/hashicorp\\/aws\\/latest\\/docs\\/resources\\/kendra_index"))
                            )),
                            jsonProperty("version", "1.0.0"),
                            jsonProperty("syncMode", "FULL_CRAWL"),
                            jsonProperty("type", "WEBCRAWLERV2")
                        )))
                    .build())
                .build())
            .indexId(exampleAwsKendraIndex.id())
            .name("example")
            .type("TEMPLATE")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:kendra:DataSource
    properties:
      configuration:
        templateConfiguration:
          template:
            fn::toJSON:
              connectionConfiguration:
                repositoryEndpointMetadata:
                  seedUrlConnections:
                    - seedUrl: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/kendra_index
              additionalProperties:
                inclusionURLIndexPatterns:
                  - https:\/\/registry[.]terraform[.]io\/providers\/hashicorp\/aws\/latest\/docs\/resources\/kendra_index
              version: 1.0.0
              syncMode: FULL_CRAWL
              type: WEBCRAWLERV2
      indexId: ${exampleAwsKendraIndex.id}
      name: example
      type: TEMPLATE
      roleArn: ${exampleAwsIamRole.arn}

Import

Using pulumi import, import Kendra Data Source using the unique identifiers of the dataSource and index separated by a slash (/). For example:

$ pulumi import aws:kendra/dataSource:DataSource example 1045d08d-66ef-4882-b3ed-dfb7df183e90/b34dfdf7-1f2b-4704-9581-79e00296845f

Constructors

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

Properties

arn ↔ Output<String>
ARN of the Data Source.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
configuration ↔ Output<DataSourceConfiguration?>
A block with the configuration information to connect to your Data Source repository. You can't specify the configuration block when the type parameter is set to CUSTOM. Detailed below.
latefinal
createdAt ↔ Output<String>
The Unix time stamp of when the Data Source was created.
latefinal
customDocumentEnrichmentConfiguration ↔ Output<DataSourceCustomDocumentEnrichmentConfiguration?>
A block with the configuration information for altering document metadata and content during the document ingestion process. For more information on how to create, modify and delete document metadata, or make other content alterations when you ingest documents into Amazon Kendra, see Customizing document metadata during the ingestion process. Detailed below.
latefinal
dataSourceId ↔ Output<String>
The unique identifiers of the Data Source.
latefinal
description ↔ Output<String?>
A description for the Data Source connector.
latefinal
errorMessage ↔ Output<String>
When the Status field value is FAILED, contains a description of the error that caused the Data Source to fail.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
indexId ↔ Output<String>
The identifier of the index for your Amazon Kendra data source.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
languageCode ↔ Output<String>
The code for a language. This allows you to support a language for all documents when creating the Data Source connector. English is supported by default. For more information on supported languages, including their codes, see Adding documents in languages other than English.
latefinal
name ↔ Output<String>
A name for your data source connector.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
roleArn ↔ Output<String?>
ARN of a role with permission to access the data source connector. For more information, see IAM roles for Amazon Kendra. You can't specify the roleArn parameter when the type parameter is set to CUSTOM. The roleArn parameter is required for all other data sources.
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
schedule ↔ Output<String?>
Sets the frequency for Amazon Kendra to check the documents in your Data Source repository and update the index. If you don't set a schedule Amazon Kendra will not periodically update the index. You can call the StartDataSourceSyncJob API to update the index.
latefinal
status ↔ Output<String>
The current status of the Data Source. When the status is ACTIVE the Data Source is ready to use. When the status is FAILED, the errorMessage field contains the reason that the Data Source failed.
latefinal
tags ↔ Output<Map<String, String>?>
Key-value map of resource tags. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
A map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
type ↔ Output<String>
The type of data source repository. For an updated list of values, refer to Valid Values for Type.
latefinal
updatedAt ↔ Output<String>
The Unix time stamp of when the Data Source was last updated.
latefinal
urn ↔ Output<String>
latefinalinherited

Methods

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

Operators

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

Static Methods

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