aws.efs.BackupPolicy

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

const fs = new aws.efs.FileSystem("fs", {creationToken: "my-product"});
const policy = new aws.efs.BackupPolicy("policy", {
    fileSystemId: fs.id,
    backupPolicy: {
        status: "ENABLED",
    },
});

import pulumi
import pulumi_aws as aws

fs = aws.efs.FileSystem("fs", creation_token="my-product")
policy = aws.efs.BackupPolicy("policy",
    file_system_id=fs.id,
    backup_policy={
        "status": "ENABLED",
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fs, err := efs.NewFileSystem(ctx, "fs", &efs.FileSystemArgs{
			CreationToken: pulumi.String("my-product"),
		})
		if err != nil {
			return err
		}
		_, err = efs.NewBackupPolicy(ctx, "policy", &efs.BackupPolicyArgs{
			FileSystemId: fs.ID(),
			BackupPolicy: &efs.BackupPolicyBackupPolicyArgs{
				Status: pulumi.String("ENABLED"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var fs = new Aws.Efs.FileSystem("fs", new()
    {
        CreationToken = "my-product",
    });

    var policy = new Aws.Efs.BackupPolicy("policy", new()
    {
        FileSystemId = fs.Id,
        BackupPolicyDetails = new Aws.Efs.Inputs.BackupPolicyBackupPolicyArgs
        {
            Status = "ENABLED",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.efs.FileSystem;
import com.pulumi.aws.efs.FileSystemArgs;
import com.pulumi.aws.efs.BackupPolicy;
import com.pulumi.aws.efs.BackupPolicyArgs;
import com.pulumi.aws.efs.inputs.BackupPolicyBackupPolicyArgs;
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 fs = new FileSystem("fs", FileSystemArgs.builder()
            .creationToken("my-product")
            .build());

        var policy = new BackupPolicy("policy", BackupPolicyArgs.builder()
            .fileSystemId(fs.id())
            .backupPolicy(BackupPolicyBackupPolicyArgs.builder()
                .status("ENABLED")
                .build())
            .build());

    }
}

resources:
  fs:
    type: aws:efs:FileSystem
    properties:
      creationToken: my-product
  policy:
    type: aws:efs:BackupPolicy
    properties:
      fileSystemId: ${fs.id}
      backupPolicy:
        status: ENABLED

var backupPolicyResource = new Aws.Efs.BackupPolicy("backupPolicyResource", new()
{
    BackupPolicyDetails = new Aws.Efs.Inputs.BackupPolicyBackupPolicyArgs
    {
        Status = "string",
    },
    FileSystemId = "string",
});

example, err := efs.NewBackupPolicy(ctx, "backupPolicyResource", &efs.BackupPolicyArgs{
	BackupPolicy: &efs.BackupPolicyBackupPolicyArgs{
		Status: pulumi.String("string"),
	},
	FileSystemId: pulumi.String("string"),
})

var backupPolicyResource = new BackupPolicy("backupPolicyResource", BackupPolicyArgs.builder()
    .backupPolicy(BackupPolicyBackupPolicyArgs.builder()
        .status("string")
        .build())
    .fileSystemId("string")
    .build());

backup_policy_resource = aws.efs.BackupPolicy("backupPolicyResource",
    backup_policy={
        "status": "string",
    },
    file_system_id="string")

const backupPolicyResource = new aws.efs.BackupPolicy("backupPolicyResource", {
    backupPolicy: {
        status: "string",
    },
    fileSystemId: "string",
});

type: aws:efs:BackupPolicy
properties:
    backupPolicy:
        status: string
    fileSystemId: string