alicloud.mse.Gateway

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

return await Deployment.RunAsync(() => 
{
    var defaultZones = AliCloud.GetZones.Invoke(new()
    {
        AvailableResourceCreation = "VSwitch",
    });

    var defaultNetworks = AliCloud.Vpc.GetNetworks.Invoke(new()
    {
        NameRegex = "default-NODELETING",
    });

    var defaultSwitches = AliCloud.Vpc.GetSwitches.Invoke(new()
    {
        VpcId = defaultNetworks.Apply(getNetworksResult => getNetworksResult.Ids[0]),
        ZoneId = defaultZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
    });

    var example = new AliCloud.Mse.Gateway("example", new()
    {
        GatewayName = "example_value",
        Replica = 2,
        Spec = "MSE_GTW_2_4_200_c",
        VswitchId = defaultSwitches.Apply(getSwitchesResult => getSwitchesResult.Ids[0]),
        BackupVswitchId = defaultSwitches.Apply(getSwitchesResult => getSwitchesResult.Ids[1]),
        VpcId = defaultNetworks.Apply(getNetworksResult => getNetworksResult.Ids[0]),
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultZones, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
			AvailableResourceCreation: pulumi.StringRef("VSwitch"),
		}, nil)
		if err != nil {
			return err
		}
		defaultNetworks, err := vpc.GetNetworks(ctx, &vpc.GetNetworksArgs{
			NameRegex: pulumi.StringRef("default-NODELETING"),
		}, nil)
		if err != nil {
			return err
		}
		defaultSwitches, err := vpc.GetSwitches(ctx, &vpc.GetSwitchesArgs{
			VpcId:  pulumi.StringRef(defaultNetworks.Ids[0]),
			ZoneId: pulumi.StringRef(defaultZones.Zones[0].Id),
		}, nil)
		if err != nil {
			return err
		}
		_, err = mse.NewGateway(ctx, "example", &mse.GatewayArgs{
			GatewayName:     pulumi.String("example_value"),
			Replica:         pulumi.Int(2),
			Spec:            pulumi.String("MSE_GTW_2_4_200_c"),
			VswitchId:       *pulumi.String(defaultSwitches.Ids[0]),
			BackupVswitchId: *pulumi.String(defaultSwitches.Ids[1]),
			VpcId:           *pulumi.String(defaultNetworks.Ids[0]),
		})
		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.VpcFunctions;
import com.pulumi.alicloud.vpc.inputs.GetNetworksArgs;
import com.pulumi.alicloud.vpc.inputs.GetSwitchesArgs;
import com.pulumi.alicloud.mse.Gateway;
import com.pulumi.alicloud.mse.GatewayArgs;
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 defaultZones = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableResourceCreation("VSwitch")
            .build());

        final var defaultNetworks = VpcFunctions.getNetworks(GetNetworksArgs.builder()
            .nameRegex("default-NODELETING")
            .build());

        final var defaultSwitches = VpcFunctions.getSwitches(GetSwitchesArgs.builder()
            .vpcId(defaultNetworks.applyValue(getNetworksResult -> getNetworksResult.ids()[0]))
            .zoneId(defaultZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .build());

        var example = new Gateway("example", GatewayArgs.builder()        
            .gatewayName("example_value")
            .replica(2)
            .spec("MSE_GTW_2_4_200_c")
            .vswitchId(defaultSwitches.applyValue(getSwitchesResult -> getSwitchesResult.ids()[0]))
            .backupVswitchId(defaultSwitches.applyValue(getSwitchesResult -> getSwitchesResult.ids()[1]))
            .vpcId(defaultNetworks.applyValue(getNetworksResult -> getNetworksResult.ids()[0]))
            .build());

    }
}

import pulumi
import pulumi_alicloud as alicloud

default_zones = alicloud.get_zones(available_resource_creation="VSwitch")
default_networks = alicloud.vpc.get_networks(name_regex="default-NODELETING")
default_switches = alicloud.vpc.get_switches(vpc_id=default_networks.ids[0],
    zone_id=default_zones.zones[0].id)
example = alicloud.mse.Gateway("example",
    gateway_name="example_value",
    replica=2,
    spec="MSE_GTW_2_4_200_c",
    vswitch_id=default_switches.ids[0],
    backup_vswitch_id=default_switches.ids[1],
    vpc_id=default_networks.ids[0])

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

const defaultZones = alicloud.getZones({
    availableResourceCreation: "VSwitch",
});
const defaultNetworks = alicloud.vpc.getNetworks({
    nameRegex: "default-NODELETING",
});
const defaultSwitches = Promise.all([defaultNetworks, defaultZones]).then(([defaultNetworks, defaultZones]) => alicloud.vpc.getSwitches({
    vpcId: defaultNetworks.ids?.[0],
    zoneId: defaultZones.zones?.[0]?.id,
}));
const example = new alicloud.mse.Gateway("example", {
    gatewayName: "example_value",
    replica: 2,
    spec: "MSE_GTW_2_4_200_c",
    vswitchId: defaultSwitches.then(defaultSwitches => defaultSwitches.ids?.[0]),
    backupVswitchId: defaultSwitches.then(defaultSwitches => defaultSwitches.ids?.[1]),
    vpcId: defaultNetworks.then(defaultNetworks => defaultNetworks.ids?.[0]),
});

resources:
  example:
    type: alicloud:mse:Gateway
    properties:
      gatewayName: example_value
      replica: 2
      spec: MSE_GTW_2_4_200_c
      vswitchId: ${defaultSwitches.ids[0]}
      backupVswitchId: ${defaultSwitches.ids[1]}
      vpcId: ${defaultNetworks.ids[0]}
variables:
  defaultZones:
    fn::invoke:
      Function: alicloud:getZones
      Arguments:
        availableResourceCreation: VSwitch
  defaultNetworks:
    fn::invoke:
      Function: alicloud:vpc:getNetworks
      Arguments:
        nameRegex: default-NODELETING
  defaultSwitches:
    fn::invoke:
      Function: alicloud:vpc:getSwitches
      Arguments:
        vpcId: ${defaultNetworks.ids[0]}
        zoneId: ${defaultZones.zones[0].id}