pulumi-aws-kotlin/com.pulumi.aws.datasync.kotlin/Task

Task

class Task : KotlinCustomResource

Manages an AWS DataSync Task, which represents a configuration for synchronization. Starting an execution of these DataSync Tasks (actually synchronizing files) is performed outside of this resource.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.datasync.Task("example", {
    destinationLocationArn: destination.arn,
    name: "example",
    sourceLocationArn: source.arn,
    options: {
        bytesPerSecond: -1,
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.datasync.Task("example",
    destination_location_arn=destination["arn"],
    name="example",
    source_location_arn=source["arn"],
    options=aws.datasync.TaskOptionsArgs(
        bytes_per_second=-1,
    ))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.DataSync.Task("example", new()
    {
        DestinationLocationArn = destination.Arn,
        Name = "example",
        SourceLocationArn = source.Arn,
        Options = new Aws.DataSync.Inputs.TaskOptionsArgs
        {
            BytesPerSecond = -1,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/datasync"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := datasync.NewTask(ctx, "example", &datasync.TaskArgs{
			DestinationLocationArn: pulumi.Any(destination.Arn),
			Name:                   pulumi.String("example"),
			SourceLocationArn:      pulumi.Any(source.Arn),
			Options: &datasync.TaskOptionsArgs{
				BytesPerSecond: -1,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard

With Scheduling

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.datasync.Task("example", {
    destinationLocationArn: destination.arn,
    name: "example",
    sourceLocationArn: source.arn,
    schedule: {
        scheduleExpression: "cron(0 12 ? * SUN,WED *)",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.datasync.Task("example",
    destination_location_arn=destination["arn"],
    name="example",
    source_location_arn=source["arn"],
    schedule=aws.datasync.TaskScheduleArgs(
        schedule_expression="cron(0 12 ? * SUN,WED *)",
    ))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.DataSync.Task("example", new()
    {
        DestinationLocationArn = destination.Arn,
        Name = "example",
        SourceLocationArn = source.Arn,
        Schedule = new Aws.DataSync.Inputs.TaskScheduleArgs
        {
            ScheduleExpression = "cron(0 12 ? * SUN,WED *)",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/datasync"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := datasync.NewTask(ctx, "example", &datasync.TaskArgs{
			DestinationLocationArn: pulumi.Any(destination.Arn),
			Name:                   pulumi.String("example"),
			SourceLocationArn:      pulumi.Any(source.Arn),
			Schedule: &datasync.TaskScheduleArgs{
				ScheduleExpression: pulumi.String("cron(0 12 ? * SUN,WED *)"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.datasync.Task;
import com.pulumi.aws.datasync.TaskArgs;
import com.pulumi.aws.datasync.inputs.TaskScheduleArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Task("example", TaskArgs.builder()
            .destinationLocationArn(destination.arn())
            .name("example")
            .sourceLocationArn(source.arn())
            .schedule(TaskScheduleArgs.builder()
                .scheduleExpression("cron(0 12 ? * SUN,WED *)")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:datasync:Task
    properties:
      destinationLocationArn: ${destination.arn}
      name: example
      sourceLocationArn: ${source.arn}
      schedule:
        scheduleExpression: cron(0 12 ? * SUN,WED *)
Content copied to clipboard

With Filtering

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.datasync.Task("example", {
    destinationLocationArn: destination.arn,
    name: "example",
    sourceLocationArn: source.arn,
    excludes: {
        filterType: "SIMPLE_PATTERN",
        value: "/folder1|/folder2",
    },
    includes: {
        filterType: "SIMPLE_PATTERN",
        value: "/folder1|/folder2",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.datasync.Task("example",
    destination_location_arn=destination["arn"],
    name="example",
    source_location_arn=source["arn"],
    excludes=aws.datasync.TaskExcludesArgs(
        filter_type="SIMPLE_PATTERN",
        value="/folder1|/folder2",
    ),
    includes=aws.datasync.TaskIncludesArgs(
        filter_type="SIMPLE_PATTERN",
        value="/folder1|/folder2",
    ))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.DataSync.Task("example", new()
    {
        DestinationLocationArn = destination.Arn,
        Name = "example",
        SourceLocationArn = source.Arn,
        Excludes = new Aws.DataSync.Inputs.TaskExcludesArgs
        {
            FilterType = "SIMPLE_PATTERN",
            Value = "/folder1|/folder2",
        },
        Includes = new Aws.DataSync.Inputs.TaskIncludesArgs
        {
            FilterType = "SIMPLE_PATTERN",
            Value = "/folder1|/folder2",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/datasync"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := datasync.NewTask(ctx, "example", &datasync.TaskArgs{
			DestinationLocationArn: pulumi.Any(destination.Arn),
			Name:                   pulumi.String("example"),
			SourceLocationArn:      pulumi.Any(source.Arn),
			Excludes: &datasync.TaskExcludesArgs{
				FilterType: pulumi.String("SIMPLE_PATTERN"),
				Value:      pulumi.String("/folder1|/folder2"),
			},
			Includes: &datasync.TaskIncludesArgs{
				FilterType: pulumi.String("SIMPLE_PATTERN"),
				Value:      pulumi.String("/folder1|/folder2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.datasync.Task;
import com.pulumi.aws.datasync.TaskArgs;
import com.pulumi.aws.datasync.inputs.TaskExcludesArgs;
import com.pulumi.aws.datasync.inputs.TaskIncludesArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Task("example", TaskArgs.builder()
            .destinationLocationArn(destination.arn())
            .name("example")
            .sourceLocationArn(source.arn())
            .excludes(TaskExcludesArgs.builder()
                .filterType("SIMPLE_PATTERN")
                .value("/folder1|/folder2")
                .build())
            .includes(TaskIncludesArgs.builder()
                .filterType("SIMPLE_PATTERN")
                .value("/folder1|/folder2")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:datasync:Task
    properties:
      destinationLocationArn: ${destination.arn}
      name: example
      sourceLocationArn: ${source.arn}
      excludes:
        filterType: SIMPLE_PATTERN
        value: /folder1|/folder2
      includes:
        filterType: SIMPLE_PATTERN
        value: /folder1|/folder2
Content copied to clipboard

Import

Using pulumi import, import aws_datasync_task using the DataSync Task Amazon Resource Name (ARN). For example:

$ pulumi import aws:datasync/task:Task example arn:aws:datasync:us-east-1:123456789012:task/task-12345678901234567
Content copied to clipboard

Properties

Link copied to clipboard
val arn: Output<String>

Amazon Resource Name (ARN) of the DataSync Task.

Link copied to clipboard
val cloudwatchLogGroupArn: Output<String>?

Amazon Resource Name (ARN) of the CloudWatch Log Group that is used to monitor and log events in the sync task.

Link copied to clipboard
val destinationLocationArn: Output<String>

Amazon Resource Name (ARN) of destination DataSync Location.

Link copied to clipboard
val excludes: Output<TaskExcludes>?

Filter rules that determines which files to exclude from a task.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val includes: Output<TaskIncludes>?

Filter rules that determines which files to include in a task.

Link copied to clipboard
val name: Output<String>

Name of the DataSync Task.

Link copied to clipboard
val options: Output<TaskOptions>?

Configuration block containing option that controls the default behavior when you start an execution of this DataSync Task. For each individual task execution, you can override these options by specifying an overriding configuration in those executions.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val schedule: Output<TaskSchedule>?

Specifies a schedule used to periodically transfer files from a source to a destination location.

Link copied to clipboard
val sourceLocationArn: Output<String>

Amazon Resource Name (ARN) of source DataSync Location.

Link copied to clipboard
val tags: Output<Map<String, String>>?

Key-value pairs of resource tags to assign to the DataSync Task. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Link copied to clipboard
val tagsAll: Output<Map<String, String>>

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

Link copied to clipboard
val taskReportConfig: Output<TaskTaskReportConfig>?

Configuration block containing the configuration of a DataSync Task Report. See task_report_config below.

Link copied to clipboard
val urn: Output<String>