alicloud.kvstore.BackupPolicy

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var creation = config.Get("creation") ?? "KVStore";
    var multiAz = config.Get("multiAz") ?? "false";
    var name = config.Get("name") ?? "kvstorebackuppolicyvpc";
    var defaultZones = AliCloud.GetZones.Invoke(new()
    {
        AvailableResourceCreation = creation,
    });

    var defaultNetwork = new AliCloud.Vpc.Network("defaultNetwork", new()
    {
        CidrBlock = "172.16.0.0/16",
    });

    var defaultSwitch = new AliCloud.Vpc.Switch("defaultSwitch", new()
    {
        VpcId = defaultNetwork.Id,
        CidrBlock = "172.16.0.0/24",
        ZoneId = defaultZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
    });

    var defaultInstance = new AliCloud.KVStore.Instance("defaultInstance", new()
    {
        InstanceClass = "Memcache",
        InstanceName = name,
        VswitchId = defaultSwitch.Id,
        PrivateIp = "172.16.0.10",
        SecurityIps = new[]
        {
            "10.0.0.1",
        },
        InstanceType = "memcache.master.small.default",
        EngineVersion = "2.8",
    });

    var defaultBackupPolicy = new AliCloud.KVStore.BackupPolicy("defaultBackupPolicy", new()
    {
        InstanceId = defaultInstance.Id,
        BackupPeriods = new[]
        {
            "Tuesday",
            "Wednesday",
        },
        BackupTime = "10:00Z-11:00Z",
    });

});

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/kvstore"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		creation := "KVStore"
		if param := cfg.Get("creation"); param != "" {
			creation = param
		}
		multiAz := "false"
		if param := cfg.Get("multiAz"); param != "" {
			multiAz = param
		}
		name := "kvstorebackuppolicyvpc"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultZones, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
			AvailableResourceCreation: pulumi.StringRef(creation),
		}, nil)
		if err != nil {
			return err
		}
		defaultNetwork, err := vpc.NewNetwork(ctx, "defaultNetwork", &vpc.NetworkArgs{
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		defaultSwitch, err := vpc.NewSwitch(ctx, "defaultSwitch", &vpc.SwitchArgs{
			VpcId:     defaultNetwork.ID(),
			CidrBlock: pulumi.String("172.16.0.0/24"),
			ZoneId:    *pulumi.String(defaultZones.Zones[0].Id),
		})
		if err != nil {
			return err
		}
		defaultInstance, err := kvstore.NewInstance(ctx, "defaultInstance", &kvstore.InstanceArgs{
			InstanceClass: pulumi.String("Memcache"),
			InstanceName:  pulumi.String(name),
			VswitchId:     defaultSwitch.ID(),
			PrivateIp:     pulumi.String("172.16.0.10"),
			SecurityIps: pulumi.StringArray{
				pulumi.String("10.0.0.1"),
			},
			InstanceType:  pulumi.String("memcache.master.small.default"),
			EngineVersion: pulumi.String("2.8"),
		})
		if err != nil {
			return err
		}
		_, err = kvstore.NewBackupPolicy(ctx, "defaultBackupPolicy", &kvstore.BackupPolicyArgs{
			InstanceId: defaultInstance.ID(),
			BackupPeriods: pulumi.StringArray{
				pulumi.String("Tuesday"),
				pulumi.String("Wednesday"),
			},
			BackupTime: pulumi.String("10:00Z-11:00Z"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.AlicloudFunctions;
import com.pulumi.alicloud.inputs.GetZonesArgs;
import com.pulumi.alicloud.vpc.Network;
import com.pulumi.alicloud.vpc.NetworkArgs;
import com.pulumi.alicloud.vpc.Switch;
import com.pulumi.alicloud.vpc.SwitchArgs;
import com.pulumi.alicloud.kvstore.Instance;
import com.pulumi.alicloud.kvstore.InstanceArgs;
import com.pulumi.alicloud.kvstore.BackupPolicy;
import com.pulumi.alicloud.kvstore.BackupPolicyArgs;
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) {
        final var config = ctx.config();
        final var creation = config.get("creation").orElse("KVStore");
        final var multiAz = config.get("multiAz").orElse("false");
        final var name = config.get("name").orElse("kvstorebackuppolicyvpc");
        final var defaultZones = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableResourceCreation(creation)
            .build());

        var defaultNetwork = new Network("defaultNetwork", NetworkArgs.builder()        
            .cidrBlock("172.16.0.0/16")
            .build());

        var defaultSwitch = new Switch("defaultSwitch", SwitchArgs.builder()        
            .vpcId(defaultNetwork.id())
            .cidrBlock("172.16.0.0/24")
            .zoneId(defaultZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .build());

        var defaultInstance = new Instance("defaultInstance", InstanceArgs.builder()        
            .instanceClass("Memcache")
            .instanceName(name)
            .vswitchId(defaultSwitch.id())
            .privateIp("172.16.0.10")
            .securityIps("10.0.0.1")
            .instanceType("memcache.master.small.default")
            .engineVersion("2.8")
            .build());

        var defaultBackupPolicy = new BackupPolicy("defaultBackupPolicy", BackupPolicyArgs.builder()        
            .instanceId(defaultInstance.id())
            .backupPeriods(            
                "Tuesday",
                "Wednesday")
            .backupTime("10:00Z-11:00Z")
            .build());

    }
}

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
creation = config.get("creation")
if creation is None:
    creation = "KVStore"
multi_az = config.get("multiAz")
if multi_az is None:
    multi_az = "false"
name = config.get("name")
if name is None:
    name = "kvstorebackuppolicyvpc"
default_zones = alicloud.get_zones(available_resource_creation=creation)
default_network = alicloud.vpc.Network("defaultNetwork", cidr_block="172.16.0.0/16")
default_switch = alicloud.vpc.Switch("defaultSwitch",
    vpc_id=default_network.id,
    cidr_block="172.16.0.0/24",
    zone_id=default_zones.zones[0].id)
default_instance = alicloud.kvstore.Instance("defaultInstance",
    instance_class="Memcache",
    instance_name=name,
    vswitch_id=default_switch.id,
    private_ip="172.16.0.10",
    security_ips=["10.0.0.1"],
    instance_type="memcache.master.small.default",
    engine_version="2.8")
default_backup_policy = alicloud.kvstore.BackupPolicy("defaultBackupPolicy",
    instance_id=default_instance.id,
    backup_periods=[
        "Tuesday",
        "Wednesday",
    ],
    backup_time="10:00Z-11:00Z")

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

const config = new pulumi.Config();
const creation = config.get("creation") || "KVStore";
const multiAz = config.get("multiAz") || "false";
const name = config.get("name") || "kvstorebackuppolicyvpc";
const defaultZones = alicloud.getZones({
    availableResourceCreation: creation,
});
const defaultNetwork = new alicloud.vpc.Network("defaultNetwork", {cidrBlock: "172.16.0.0/16"});
const defaultSwitch = new alicloud.vpc.Switch("defaultSwitch", {
    vpcId: defaultNetwork.id,
    cidrBlock: "172.16.0.0/24",
    zoneId: defaultZones.then(defaultZones => defaultZones.zones?.[0]?.id),
});
const defaultInstance = new alicloud.kvstore.Instance("defaultInstance", {
    instanceClass: "Memcache",
    instanceName: name,
    vswitchId: defaultSwitch.id,
    privateIp: "172.16.0.10",
    securityIps: ["10.0.0.1"],
    instanceType: "memcache.master.small.default",
    engineVersion: "2.8",
});
const defaultBackupPolicy = new alicloud.kvstore.BackupPolicy("defaultBackupPolicy", {
    instanceId: defaultInstance.id,
    backupPeriods: [
        "Tuesday",
        "Wednesday",
    ],
    backupTime: "10:00Z-11:00Z",
});

configuration:
  creation:
    type: string
    default: KVStore
  multiAz:
    type: string
    default: 'false'
  name:
    type: string
    default: kvstorebackuppolicyvpc
resources:
  defaultNetwork:
    type: alicloud:vpc:Network
    properties:
      cidrBlock: 172.16.0.0/16
  defaultSwitch:
    type: alicloud:vpc:Switch
    properties:
      vpcId: ${defaultNetwork.id}
      cidrBlock: 172.16.0.0/24
      zoneId: ${defaultZones.zones[0].id}
  defaultInstance:
    type: alicloud:kvstore:Instance
    properties:
      instanceClass: Memcache
      instanceName: ${name}
      vswitchId: ${defaultSwitch.id}
      privateIp: 172.16.0.10
      securityIps:
        - 10.0.0.1
      instanceType: memcache.master.small.default
      engineVersion: '2.8'
  defaultBackupPolicy:
    type: alicloud:kvstore:BackupPolicy
    properties:
      instanceId: ${defaultInstance.id}
      backupPeriods:
        - Tuesday
        - Wednesday
      backupTime: 10:00Z-11:00Z
variables:
  defaultZones:
    fn::invoke:
      Function: alicloud:getZones
      Arguments:
        availableResourceCreation: ${creation}