alicloud.vpc.getForwardEntries

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "forward-entry-config-example-name";
    var defaultZones = AliCloud.GetZones.Invoke(new()
    {
        AvailableResourceCreation = "VSwitch",
    });

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

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

    var defaultNatGateway = new AliCloud.Vpc.NatGateway("defaultNatGateway", new()
    {
        VpcId = defaultNetwork.Id,
        InternetChargeType = "PayByLcu",
        NatGatewayName = name,
        NatType = "Enhanced",
        VswitchId = defaultSwitch.Id,
    });

    var defaultEipAddress = new AliCloud.Ecs.EipAddress("defaultEipAddress", new()
    {
        AddressName = name,
    });

    var defaultEipAssociation = new AliCloud.Ecs.EipAssociation("defaultEipAssociation", new()
    {
        AllocationId = defaultEipAddress.Id,
        InstanceId = defaultNatGateway.Id,
    });

    var defaultForwardEntry = new AliCloud.Vpc.ForwardEntry("defaultForwardEntry", new()
    {
        ForwardTableId = defaultNatGateway.ForwardTableIds,
        ExternalIp = defaultEipAddress.IpAddress,
        ExternalPort = "80",
        IpProtocol = "tcp",
        InternalIp = "172.16.0.3",
        InternalPort = "8080",
    });

    var defaultForwardEntries = AliCloud.Vpc.GetForwardEntries.Invoke(new()
    {
        ForwardTableId = defaultForwardEntry.ForwardTableId,
    });

});

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ecs"
	"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, "")
		name := "forward-entry-config-example-name"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultZones, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
			AvailableResourceCreation: pulumi.StringRef("VSwitch"),
		}, nil)
		if err != nil {
			return err
		}
		defaultNetwork, err := vpc.NewNetwork(ctx, "defaultNetwork", &vpc.NetworkArgs{
			VpcName:   pulumi.String(name),
			CidrBlock: pulumi.String("172.16.0.0/12"),
		})
		if err != nil {
			return err
		}
		defaultSwitch, err := vpc.NewSwitch(ctx, "defaultSwitch", &vpc.SwitchArgs{
			VpcId:       defaultNetwork.ID(),
			CidrBlock:   pulumi.String("172.16.0.0/21"),
			ZoneId:      *pulumi.String(defaultZones.Zones[0].Id),
			VswitchName: pulumi.String(name),
		})
		if err != nil {
			return err
		}
		defaultNatGateway, err := vpc.NewNatGateway(ctx, "defaultNatGateway", &vpc.NatGatewayArgs{
			VpcId:              defaultNetwork.ID(),
			InternetChargeType: pulumi.String("PayByLcu"),
			NatGatewayName:     pulumi.String(name),
			NatType:            pulumi.String("Enhanced"),
			VswitchId:          defaultSwitch.ID(),
		})
		if err != nil {
			return err
		}
		defaultEipAddress, err := ecs.NewEipAddress(ctx, "defaultEipAddress", &ecs.EipAddressArgs{
			AddressName: pulumi.String(name),
		})
		if err != nil {
			return err
		}
		_, err = ecs.NewEipAssociation(ctx, "defaultEipAssociation", &ecs.EipAssociationArgs{
			AllocationId: defaultEipAddress.ID(),
			InstanceId:   defaultNatGateway.ID(),
		})
		if err != nil {
			return err
		}
		defaultForwardEntry, err := vpc.NewForwardEntry(ctx, "defaultForwardEntry", &vpc.ForwardEntryArgs{
			ForwardTableId: defaultNatGateway.ForwardTableIds,
			ExternalIp:     defaultEipAddress.IpAddress,
			ExternalPort:   pulumi.String("80"),
			IpProtocol:     pulumi.String("tcp"),
			InternalIp:     pulumi.String("172.16.0.3"),
			InternalPort:   pulumi.String("8080"),
		})
		if err != nil {
			return err
		}
		_ = vpc.GetForwardEntriesOutput(ctx, vpc.GetForwardEntriesOutputArgs{
			ForwardTableId: defaultForwardEntry.ForwardTableId,
		}, nil)
		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.vpc.NatGateway;
import com.pulumi.alicloud.vpc.NatGatewayArgs;
import com.pulumi.alicloud.ecs.EipAddress;
import com.pulumi.alicloud.ecs.EipAddressArgs;
import com.pulumi.alicloud.ecs.EipAssociation;
import com.pulumi.alicloud.ecs.EipAssociationArgs;
import com.pulumi.alicloud.vpc.ForwardEntry;
import com.pulumi.alicloud.vpc.ForwardEntryArgs;
import com.pulumi.alicloud.vpc.VpcFunctions;
import com.pulumi.alicloud.vpc.inputs.GetForwardEntriesArgs;
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 name = config.get("name").orElse("forward-entry-config-example-name");
        final var defaultZones = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableResourceCreation("VSwitch")
            .build());

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

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

        var defaultNatGateway = new NatGateway("defaultNatGateway", NatGatewayArgs.builder()        
            .vpcId(defaultNetwork.id())
            .internetChargeType("PayByLcu")
            .natGatewayName(name)
            .natType("Enhanced")
            .vswitchId(defaultSwitch.id())
            .build());

        var defaultEipAddress = new EipAddress("defaultEipAddress", EipAddressArgs.builder()        
            .addressName(name)
            .build());

        var defaultEipAssociation = new EipAssociation("defaultEipAssociation", EipAssociationArgs.builder()        
            .allocationId(defaultEipAddress.id())
            .instanceId(defaultNatGateway.id())
            .build());

        var defaultForwardEntry = new ForwardEntry("defaultForwardEntry", ForwardEntryArgs.builder()        
            .forwardTableId(defaultNatGateway.forwardTableIds())
            .externalIp(defaultEipAddress.ipAddress())
            .externalPort("80")
            .ipProtocol("tcp")
            .internalIp("172.16.0.3")
            .internalPort("8080")
            .build());

        final var defaultForwardEntries = VpcFunctions.getForwardEntries(GetForwardEntriesArgs.builder()
            .forwardTableId(defaultForwardEntry.forwardTableId())
            .build());

    }
}

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "forward-entry-config-example-name"
default_zones = alicloud.get_zones(available_resource_creation="VSwitch")
default_network = alicloud.vpc.Network("defaultNetwork",
    vpc_name=name,
    cidr_block="172.16.0.0/12")
default_switch = alicloud.vpc.Switch("defaultSwitch",
    vpc_id=default_network.id,
    cidr_block="172.16.0.0/21",
    zone_id=default_zones.zones[0].id,
    vswitch_name=name)
default_nat_gateway = alicloud.vpc.NatGateway("defaultNatGateway",
    vpc_id=default_network.id,
    internet_charge_type="PayByLcu",
    nat_gateway_name=name,
    nat_type="Enhanced",
    vswitch_id=default_switch.id)
default_eip_address = alicloud.ecs.EipAddress("defaultEipAddress", address_name=name)
default_eip_association = alicloud.ecs.EipAssociation("defaultEipAssociation",
    allocation_id=default_eip_address.id,
    instance_id=default_nat_gateway.id)
default_forward_entry = alicloud.vpc.ForwardEntry("defaultForwardEntry",
    forward_table_id=default_nat_gateway.forward_table_ids,
    external_ip=default_eip_address.ip_address,
    external_port="80",
    ip_protocol="tcp",
    internal_ip="172.16.0.3",
    internal_port="8080")
default_forward_entries = alicloud.vpc.get_forward_entries_output(forward_table_id=default_forward_entry.forward_table_id)

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

const config = new pulumi.Config();
const name = config.get("name") || "forward-entry-config-example-name";
const defaultZones = alicloud.getZones({
    availableResourceCreation: "VSwitch",
});
const defaultNetwork = new alicloud.vpc.Network("defaultNetwork", {
    vpcName: name,
    cidrBlock: "172.16.0.0/12",
});
const defaultSwitch = new alicloud.vpc.Switch("defaultSwitch", {
    vpcId: defaultNetwork.id,
    cidrBlock: "172.16.0.0/21",
    zoneId: defaultZones.then(defaultZones => defaultZones.zones?.[0]?.id),
    vswitchName: name,
});
const defaultNatGateway = new alicloud.vpc.NatGateway("defaultNatGateway", {
    vpcId: defaultNetwork.id,
    internetChargeType: "PayByLcu",
    natGatewayName: name,
    natType: "Enhanced",
    vswitchId: defaultSwitch.id,
});
const defaultEipAddress = new alicloud.ecs.EipAddress("defaultEipAddress", {addressName: name});
const defaultEipAssociation = new alicloud.ecs.EipAssociation("defaultEipAssociation", {
    allocationId: defaultEipAddress.id,
    instanceId: defaultNatGateway.id,
});
const defaultForwardEntry = new alicloud.vpc.ForwardEntry("defaultForwardEntry", {
    forwardTableId: defaultNatGateway.forwardTableIds,
    externalIp: defaultEipAddress.ipAddress,
    externalPort: "80",
    ipProtocol: "tcp",
    internalIp: "172.16.0.3",
    internalPort: "8080",
});
const defaultForwardEntries = alicloud.vpc.getForwardEntriesOutput({
    forwardTableId: defaultForwardEntry.forwardTableId,
});

configuration:
  name:
    type: string
    default: forward-entry-config-example-name
resources:
  defaultNetwork:
    type: alicloud:vpc:Network
    properties:
      vpcName: ${name}
      cidrBlock: 172.16.0.0/12
  defaultSwitch:
    type: alicloud:vpc:Switch
    properties:
      vpcId: ${defaultNetwork.id}
      cidrBlock: 172.16.0.0/21
      zoneId: ${defaultZones.zones[0].id}
      vswitchName: ${name}
  defaultNatGateway:
    type: alicloud:vpc:NatGateway
    properties:
      vpcId: ${defaultNetwork.id}
      internetChargeType: PayByLcu
      natGatewayName: ${name}
      natType: Enhanced
      vswitchId: ${defaultSwitch.id}
  defaultEipAddress:
    type: alicloud:ecs:EipAddress
    properties:
      addressName: ${name}
  defaultEipAssociation:
    type: alicloud:ecs:EipAssociation
    properties:
      allocationId: ${defaultEipAddress.id}
      instanceId: ${defaultNatGateway.id}
  defaultForwardEntry:
    type: alicloud:vpc:ForwardEntry
    properties:
      forwardTableId: ${defaultNatGateway.forwardTableIds}
      externalIp: ${defaultEipAddress.ipAddress}
      externalPort: '80'
      ipProtocol: tcp
      internalIp: 172.16.0.3
      internalPort: '8080'
variables:
  defaultZones:
    fn::invoke:
      Function: alicloud:getZones
      Arguments:
        availableResourceCreation: VSwitch
  defaultForwardEntries:
    fn::invoke:
      Function: alicloud:vpc:getForwardEntries
      Arguments:
        forwardTableId: ${defaultForwardEntry.forwardTableId}