volcengine.vpn.Connections

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

const fooVpc = new volcengine.vpc.Vpc("fooVpc", {
    vpcName: "acc-test-vpc",
    cidrBlock: "172.16.0.0/16",
});
const fooSubnet = new volcengine.vpc.Subnet("fooSubnet", {
    subnetName: "acc-test-subnet",
    cidrBlock: "172.16.0.0/24",
    zoneId: "cn-beijing-a",
    vpcId: fooVpc.id,
});
const fooGateway = new volcengine.vpn.Gateway("fooGateway", {
    vpcId: fooVpc.id,
    subnetId: fooSubnet.id,
    bandwidth: 20,
    vpnGatewayName: "acc-test",
    description: "acc-test",
    period: 2,
    projectName: "default",
});
const fooCustomerGateway = new volcengine.vpn.CustomerGateway("fooCustomerGateway", {
    ipAddress: "192.0.1.3",
    customerGatewayName: "acc-test",
    description: "acc-test",
    projectName: "default",
});
const fooConnection = new volcengine.vpn.Connection("fooConnection", {
    vpnConnectionName: "acc-tf-test",
    description: "acc-tf-test",
    vpnGatewayId: fooGateway.id,
    customerGatewayId: fooCustomerGateway.id,
    localSubnets: ["192.168.0.0/22"],
    remoteSubnets: ["192.161.0.0/20"],
    dpdAction: "none",
    natTraversal: true,
    ikeConfigPsk: "acctest@!3",
    ikeConfigVersion: "ikev1",
    ikeConfigMode: "main",
    ikeConfigEncAlg: "aes",
    ikeConfigAuthAlg: "md5",
    ikeConfigDhGroup: "group2",
    ikeConfigLifetime: 9000,
    ikeConfigLocalId: "acc_test",
    ikeConfigRemoteId: "acc_test",
    ipsecConfigEncAlg: "aes",
    ipsecConfigAuthAlg: "sha256",
    ipsecConfigDhGroup: "group2",
    ipsecConfigLifetime: 9000,
    projectName: "default",
});
const fooConnections = volcengine.vpn.ConnectionsOutput({
    ids: [fooConnection.id],
});

import pulumi
import pulumi_volcengine as volcengine

foo_vpc = volcengine.vpc.Vpc("fooVpc",
    vpc_name="acc-test-vpc",
    cidr_block="172.16.0.0/16")
foo_subnet = volcengine.vpc.Subnet("fooSubnet",
    subnet_name="acc-test-subnet",
    cidr_block="172.16.0.0/24",
    zone_id="cn-beijing-a",
    vpc_id=foo_vpc.id)
foo_gateway = volcengine.vpn.Gateway("fooGateway",
    vpc_id=foo_vpc.id,
    subnet_id=foo_subnet.id,
    bandwidth=20,
    vpn_gateway_name="acc-test",
    description="acc-test",
    period=2,
    project_name="default")
foo_customer_gateway = volcengine.vpn.CustomerGateway("fooCustomerGateway",
    ip_address="192.0.1.3",
    customer_gateway_name="acc-test",
    description="acc-test",
    project_name="default")
foo_connection = volcengine.vpn.Connection("fooConnection",
    vpn_connection_name="acc-tf-test",
    description="acc-tf-test",
    vpn_gateway_id=foo_gateway.id,
    customer_gateway_id=foo_customer_gateway.id,
    local_subnets=["192.168.0.0/22"],
    remote_subnets=["192.161.0.0/20"],
    dpd_action="none",
    nat_traversal=True,
    ike_config_psk="acctest@!3",
    ike_config_version="ikev1",
    ike_config_mode="main",
    ike_config_enc_alg="aes",
    ike_config_auth_alg="md5",
    ike_config_dh_group="group2",
    ike_config_lifetime=9000,
    ike_config_local_id="acc_test",
    ike_config_remote_id="acc_test",
    ipsec_config_enc_alg="aes",
    ipsec_config_auth_alg="sha256",
    ipsec_config_dh_group="group2",
    ipsec_config_lifetime=9000,
    project_name="default")
foo_connections = volcengine.vpn.connections_output(ids=[foo_connection.id])

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vpc"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vpn"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooVpc, err := vpc.NewVpc(ctx, "fooVpc", &vpc.VpcArgs{
			VpcName:   pulumi.String("acc-test-vpc"),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		fooSubnet, err := vpc.NewSubnet(ctx, "fooSubnet", &vpc.SubnetArgs{
			SubnetName: pulumi.String("acc-test-subnet"),
			CidrBlock:  pulumi.String("172.16.0.0/24"),
			ZoneId:     pulumi.String("cn-beijing-a"),
			VpcId:      fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		fooGateway, err := vpn.NewGateway(ctx, "fooGateway", &vpn.GatewayArgs{
			VpcId:          fooVpc.ID(),
			SubnetId:       fooSubnet.ID(),
			Bandwidth:      pulumi.Int(20),
			VpnGatewayName: pulumi.String("acc-test"),
			Description:    pulumi.String("acc-test"),
			Period:         pulumi.Int(2),
			ProjectName:    pulumi.String("default"),
		})
		if err != nil {
			return err
		}
		fooCustomerGateway, err := vpn.NewCustomerGateway(ctx, "fooCustomerGateway", &vpn.CustomerGatewayArgs{
			IpAddress:           pulumi.String("192.0.1.3"),
			CustomerGatewayName: pulumi.String("acc-test"),
			Description:         pulumi.String("acc-test"),
			ProjectName:         pulumi.String("default"),
		})
		if err != nil {
			return err
		}
		fooConnection, err := vpn.NewConnection(ctx, "fooConnection", &vpn.ConnectionArgs{
			VpnConnectionName: pulumi.String("acc-tf-test"),
			Description:       pulumi.String("acc-tf-test"),
			VpnGatewayId:      fooGateway.ID(),
			CustomerGatewayId: fooCustomerGateway.ID(),
			LocalSubnets: pulumi.StringArray{
				pulumi.String("192.168.0.0/22"),
			},
			RemoteSubnets: pulumi.StringArray{
				pulumi.String("192.161.0.0/20"),
			},
			DpdAction:           pulumi.String("none"),
			NatTraversal:        pulumi.Bool(true),
			IkeConfigPsk:        pulumi.String("acctest@!3"),
			IkeConfigVersion:    pulumi.String("ikev1"),
			IkeConfigMode:       pulumi.String("main"),
			IkeConfigEncAlg:     pulumi.String("aes"),
			IkeConfigAuthAlg:    pulumi.String("md5"),
			IkeConfigDhGroup:    pulumi.String("group2"),
			IkeConfigLifetime:   pulumi.Int(9000),
			IkeConfigLocalId:    pulumi.String("acc_test"),
			IkeConfigRemoteId:   pulumi.String("acc_test"),
			IpsecConfigEncAlg:   pulumi.String("aes"),
			IpsecConfigAuthAlg:  pulumi.String("sha256"),
			IpsecConfigDhGroup:  pulumi.String("group2"),
			IpsecConfigLifetime: pulumi.Int(9000),
			ProjectName:         pulumi.String("default"),
		})
		if err != nil {
			return err
		}
		_ = vpn.ConnectionsOutput(ctx, vpn.ConnectionsOutputArgs{
			Ids: pulumi.StringArray{
				fooConnection.ID(),
			},
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var fooVpc = new Volcengine.Vpc.Vpc("fooVpc", new()
    {
        VpcName = "acc-test-vpc",
        CidrBlock = "172.16.0.0/16",
    });

    var fooSubnet = new Volcengine.Vpc.Subnet("fooSubnet", new()
    {
        SubnetName = "acc-test-subnet",
        CidrBlock = "172.16.0.0/24",
        ZoneId = "cn-beijing-a",
        VpcId = fooVpc.Id,
    });

    var fooGateway = new Volcengine.Vpn.Gateway("fooGateway", new()
    {
        VpcId = fooVpc.Id,
        SubnetId = fooSubnet.Id,
        Bandwidth = 20,
        VpnGatewayName = "acc-test",
        Description = "acc-test",
        Period = 2,
        ProjectName = "default",
    });

    var fooCustomerGateway = new Volcengine.Vpn.CustomerGateway("fooCustomerGateway", new()
    {
        IpAddress = "192.0.1.3",
        CustomerGatewayName = "acc-test",
        Description = "acc-test",
        ProjectName = "default",
    });

    var fooConnection = new Volcengine.Vpn.Connection("fooConnection", new()
    {
        VpnConnectionName = "acc-tf-test",
        Description = "acc-tf-test",
        VpnGatewayId = fooGateway.Id,
        CustomerGatewayId = fooCustomerGateway.Id,
        LocalSubnets = new[]
        {
            "192.168.0.0/22",
        },
        RemoteSubnets = new[]
        {
            "192.161.0.0/20",
        },
        DpdAction = "none",
        NatTraversal = true,
        IkeConfigPsk = "acctest@!3",
        IkeConfigVersion = "ikev1",
        IkeConfigMode = "main",
        IkeConfigEncAlg = "aes",
        IkeConfigAuthAlg = "md5",
        IkeConfigDhGroup = "group2",
        IkeConfigLifetime = 9000,
        IkeConfigLocalId = "acc_test",
        IkeConfigRemoteId = "acc_test",
        IpsecConfigEncAlg = "aes",
        IpsecConfigAuthAlg = "sha256",
        IpsecConfigDhGroup = "group2",
        IpsecConfigLifetime = 9000,
        ProjectName = "default",
    });

    var fooConnections = Volcengine.Vpn.Connections.Invoke(new()
    {
        Ids = new[]
        {
            fooConnection.Id,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.vpc.Vpc;
import com.pulumi.volcengine.vpc.VpcArgs;
import com.pulumi.volcengine.vpc.Subnet;
import com.pulumi.volcengine.vpc.SubnetArgs;
import com.pulumi.volcengine.vpn.Gateway;
import com.pulumi.volcengine.vpn.GatewayArgs;
import com.pulumi.volcengine.vpn.CustomerGateway;
import com.pulumi.volcengine.vpn.CustomerGatewayArgs;
import com.pulumi.volcengine.vpn.Connection;
import com.pulumi.volcengine.vpn.ConnectionArgs;
import com.pulumi.volcengine.vpn.VpnFunctions;
import com.pulumi.volcengine.vpn.inputs.ConnectionsArgs;
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 fooVpc = new Vpc("fooVpc", VpcArgs.builder()        
            .vpcName("acc-test-vpc")
            .cidrBlock("172.16.0.0/16")
            .build());

        var fooSubnet = new Subnet("fooSubnet", SubnetArgs.builder()        
            .subnetName("acc-test-subnet")
            .cidrBlock("172.16.0.0/24")
            .zoneId("cn-beijing-a")
            .vpcId(fooVpc.id())
            .build());

        var fooGateway = new Gateway("fooGateway", GatewayArgs.builder()        
            .vpcId(fooVpc.id())
            .subnetId(fooSubnet.id())
            .bandwidth(20)
            .vpnGatewayName("acc-test")
            .description("acc-test")
            .period(2)
            .projectName("default")
            .build());

        var fooCustomerGateway = new CustomerGateway("fooCustomerGateway", CustomerGatewayArgs.builder()        
            .ipAddress("192.0.1.3")
            .customerGatewayName("acc-test")
            .description("acc-test")
            .projectName("default")
            .build());

        var fooConnection = new Connection("fooConnection", ConnectionArgs.builder()        
            .vpnConnectionName("acc-tf-test")
            .description("acc-tf-test")
            .vpnGatewayId(fooGateway.id())
            .customerGatewayId(fooCustomerGateway.id())
            .localSubnets("192.168.0.0/22")
            .remoteSubnets("192.161.0.0/20")
            .dpdAction("none")
            .natTraversal(true)
            .ikeConfigPsk("acctest@!3")
            .ikeConfigVersion("ikev1")
            .ikeConfigMode("main")
            .ikeConfigEncAlg("aes")
            .ikeConfigAuthAlg("md5")
            .ikeConfigDhGroup("group2")
            .ikeConfigLifetime(9000)
            .ikeConfigLocalId("acc_test")
            .ikeConfigRemoteId("acc_test")
            .ipsecConfigEncAlg("aes")
            .ipsecConfigAuthAlg("sha256")
            .ipsecConfigDhGroup("group2")
            .ipsecConfigLifetime(9000)
            .projectName("default")
            .build());

        final var fooConnections = VpnFunctions.Connections(ConnectionsArgs.builder()
            .ids(fooConnection.id())
            .build());

    }
}

resources:
  fooVpc:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc
      cidrBlock: 172.16.0.0/16
  fooSubnet:
    type: volcengine:vpc:Subnet
    properties:
      subnetName: acc-test-subnet
      cidrBlock: 172.16.0.0/24
      zoneId: cn-beijing-a
      vpcId: ${fooVpc.id}
  fooGateway:
    type: volcengine:vpn:Gateway
    properties:
      vpcId: ${fooVpc.id}
      subnetId: ${fooSubnet.id}
      bandwidth: 20
      vpnGatewayName: acc-test
      description: acc-test
      period: 2
      projectName: default
  fooCustomerGateway:
    type: volcengine:vpn:CustomerGateway
    properties:
      ipAddress: 192.0.1.3
      customerGatewayName: acc-test
      description: acc-test
      projectName: default
  fooConnection:
    type: volcengine:vpn:Connection
    properties:
      vpnConnectionName: acc-tf-test
      description: acc-tf-test
      vpnGatewayId: ${fooGateway.id}
      customerGatewayId: ${fooCustomerGateway.id}
      localSubnets:
        - 192.168.0.0/22
      remoteSubnets:
        - 192.161.0.0/20
      dpdAction: none
      natTraversal: true
      ikeConfigPsk: acctest@!3
      ikeConfigVersion: ikev1
      ikeConfigMode: main
      ikeConfigEncAlg: aes
      ikeConfigAuthAlg: md5
      ikeConfigDhGroup: group2
      ikeConfigLifetime: 9000
      ikeConfigLocalId: acc_test
      ikeConfigRemoteId: acc_test
      ipsecConfigEncAlg: aes
      ipsecConfigAuthAlg: sha256
      ipsecConfigDhGroup: group2
      ipsecConfigLifetime: 9000
      projectName: default
variables:
  fooConnections:
    fn::invoke:
      Function: volcengine:vpn:Connections
      Arguments:
        ids:
          - ${fooConnection.id}

function connections(args: ConnectionsArgs, opts?: InvokeOptions): Promise<ConnectionsResult>
function connectionsOutput(args: ConnectionsOutputArgs, opts?: InvokeOptions): Output<ConnectionsResult>

def connections(attach_status: Optional[str] = None,
                attach_type: Optional[str] = None,
                customer_gateway_id: Optional[str] = None,
                ids: Optional[Sequence[str]] = None,
                name_regex: Optional[str] = None,
                output_file: Optional[str] = None,
                project_name: Optional[str] = None,
                spec: Optional[str] = None,
                status: Optional[str] = None,
                transit_router_id: Optional[str] = None,
                vpn_connection_names: Optional[Sequence[str]] = None,
                vpn_gateway_id: Optional[str] = None,
                opts: Optional[InvokeOptions] = None) -> ConnectionsResult
def connections_output(attach_status: Optional[pulumi.Input[str]] = None,
                attach_type: Optional[pulumi.Input[str]] = None,
                customer_gateway_id: Optional[pulumi.Input[str]] = None,
                ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                name_regex: Optional[pulumi.Input[str]] = None,
                output_file: Optional[pulumi.Input[str]] = None,
                project_name: Optional[pulumi.Input[str]] = None,
                spec: Optional[pulumi.Input[str]] = None,
                status: Optional[pulumi.Input[str]] = None,
                transit_router_id: Optional[pulumi.Input[str]] = None,
                vpn_connection_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                vpn_gateway_id: Optional[pulumi.Input[str]] = None,
                opts: Optional[InvokeOptions] = None) -> Output[ConnectionsResult]

func Connections(ctx *Context, args *ConnectionsArgs, opts ...InvokeOption) (*ConnectionsResult, error)
func ConnectionsOutput(ctx *Context, args *ConnectionsOutputArgs, opts ...InvokeOption) ConnectionsResultOutput

public static class Connections 
{
    public static Task<ConnectionsResult> InvokeAsync(ConnectionsArgs args, InvokeOptions? opts = null)
    public static Output<ConnectionsResult> Invoke(ConnectionsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<ConnectionsResult> connections(ConnectionsArgs args, InvokeOptions options)
public static Output<ConnectionsResult> connections(ConnectionsArgs args, InvokeOptions options)

fn::invoke:
  function: volcengine:vpn:Connections
  arguments:
    # arguments dictionary