scaleway.getVpcPublicPatRule

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Lbrlabs.PulumiPackage.Scaleway;
using Scaleway = Pulumi.Scaleway;

return await Deployment.RunAsync(() => 
{
    var pg01 = new Scaleway.VpcPublicGateway("pg01", new()
    {
        Type = "VPC-GW-S",
    });

    var dhcp01 = new Scaleway.VpcPublicGatewayDhcp("dhcp01", new()
    {
        Subnet = "192.168.1.0/24",
    });

    var pn01 = new Scaleway.VpcPrivateNetwork("pn01");

    var gn01 = new Scaleway.VpcGatewayNetwork("gn01", new()
    {
        GatewayId = pg01.Id,
        PrivateNetworkId = pn01.Id,
        DhcpId = dhcp01.Id,
        CleanupDhcp = true,
        EnableMasquerade = true,
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            pn01,
        },
    });

    var mainVpcPublicGatewayPatRule = new Scaleway.VpcPublicGatewayPatRule("mainVpcPublicGatewayPatRule", new()
    {
        GatewayId = pg01.Id,
        PrivateIp = dhcp01.Address,
        PrivatePort = 42,
        PublicPort = 42,
        Protocol = "both",
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            gn01,
            pn01,
        },
    });

    var mainVpcPublicPatRule = Scaleway.GetVpcPublicPatRule.Invoke(new()
    {
        PatRuleId = mainVpcPublicGatewayPatRule.Id,
    });

});

package main

import (
	"github.com/lbrlabs/pulumi-scaleway/sdk/go/scaleway"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		pg01, err := scaleway.NewVpcPublicGateway(ctx, "pg01", &scaleway.VpcPublicGatewayArgs{
			Type: pulumi.String("VPC-GW-S"),
		})
		if err != nil {
			return err
		}
		dhcp01, err := scaleway.NewVpcPublicGatewayDhcp(ctx, "dhcp01", &scaleway.VpcPublicGatewayDhcpArgs{
			Subnet: pulumi.String("192.168.1.0/24"),
		})
		if err != nil {
			return err
		}
		pn01, err := scaleway.NewVpcPrivateNetwork(ctx, "pn01", nil)
		if err != nil {
			return err
		}
		gn01, err := scaleway.NewVpcGatewayNetwork(ctx, "gn01", &scaleway.VpcGatewayNetworkArgs{
			GatewayId:        pg01.ID(),
			PrivateNetworkId: pn01.ID(),
			DhcpId:           dhcp01.ID(),
			CleanupDhcp:      pulumi.Bool(true),
			EnableMasquerade: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			pn01,
		}))
		if err != nil {
			return err
		}
		mainVpcPublicGatewayPatRule, err := scaleway.NewVpcPublicGatewayPatRule(ctx, "mainVpcPublicGatewayPatRule", &scaleway.VpcPublicGatewayPatRuleArgs{
			GatewayId:   pg01.ID(),
			PrivateIp:   dhcp01.Address,
			PrivatePort: pulumi.Int(42),
			PublicPort:  pulumi.Int(42),
			Protocol:    pulumi.String("both"),
		}, pulumi.DependsOn([]pulumi.Resource{
			gn01,
			pn01,
		}))
		if err != nil {
			return err
		}
		_ = scaleway.GetVpcPublicPatRuleOutput(ctx, scaleway.GetVpcPublicPatRuleOutputArgs{
			PatRuleId: mainVpcPublicGatewayPatRule.ID(),
		}, nil)
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.VpcPublicGateway;
import com.pulumi.scaleway.VpcPublicGatewayArgs;
import com.pulumi.scaleway.VpcPublicGatewayDhcp;
import com.pulumi.scaleway.VpcPublicGatewayDhcpArgs;
import com.pulumi.scaleway.VpcPrivateNetwork;
import com.pulumi.scaleway.VpcGatewayNetwork;
import com.pulumi.scaleway.VpcGatewayNetworkArgs;
import com.pulumi.scaleway.VpcPublicGatewayPatRule;
import com.pulumi.scaleway.VpcPublicGatewayPatRuleArgs;
import com.pulumi.scaleway.ScalewayFunctions;
import com.pulumi.scaleway.inputs.GetVpcPublicPatRuleArgs;
import com.pulumi.resources.CustomResourceOptions;
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 pg01 = new VpcPublicGateway("pg01", VpcPublicGatewayArgs.builder()        
            .type("VPC-GW-S")
            .build());

        var dhcp01 = new VpcPublicGatewayDhcp("dhcp01", VpcPublicGatewayDhcpArgs.builder()        
            .subnet("192.168.1.0/24")
            .build());

        var pn01 = new VpcPrivateNetwork("pn01");

        var gn01 = new VpcGatewayNetwork("gn01", VpcGatewayNetworkArgs.builder()        
            .gatewayId(pg01.id())
            .privateNetworkId(pn01.id())
            .dhcpId(dhcp01.id())
            .cleanupDhcp(true)
            .enableMasquerade(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(pn01)
                .build());

        var mainVpcPublicGatewayPatRule = new VpcPublicGatewayPatRule("mainVpcPublicGatewayPatRule", VpcPublicGatewayPatRuleArgs.builder()        
            .gatewayId(pg01.id())
            .privateIp(dhcp01.address())
            .privatePort(42)
            .publicPort(42)
            .protocol("both")
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    gn01,
                    pn01)
                .build());

        final var mainVpcPublicPatRule = ScalewayFunctions.getVpcPublicPatRule(GetVpcPublicPatRuleArgs.builder()
            .patRuleId(mainVpcPublicGatewayPatRule.id())
            .build());

    }
}

import pulumi
import lbrlabs_pulumi_scaleway as scaleway
import pulumi_scaleway as scaleway

pg01 = scaleway.VpcPublicGateway("pg01", type="VPC-GW-S")
dhcp01 = scaleway.VpcPublicGatewayDhcp("dhcp01", subnet="192.168.1.0/24")
pn01 = scaleway.VpcPrivateNetwork("pn01")
gn01 = scaleway.VpcGatewayNetwork("gn01",
    gateway_id=pg01.id,
    private_network_id=pn01.id,
    dhcp_id=dhcp01.id,
    cleanup_dhcp=True,
    enable_masquerade=True,
    opts=pulumi.ResourceOptions(depends_on=[pn01]))
main_vpc_public_gateway_pat_rule = scaleway.VpcPublicGatewayPatRule("mainVpcPublicGatewayPatRule",
    gateway_id=pg01.id,
    private_ip=dhcp01.address,
    private_port=42,
    public_port=42,
    protocol="both",
    opts=pulumi.ResourceOptions(depends_on=[
            gn01,
            pn01,
        ]))
main_vpc_public_pat_rule = scaleway.get_vpc_public_pat_rule_output(pat_rule_id=main_vpc_public_gateway_pat_rule.id)

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@lbrlabs/pulumi-scaleway";
import * as scaleway from "@pulumi/scaleway";

const pg01 = new scaleway.VpcPublicGateway("pg01", {type: "VPC-GW-S"});
const dhcp01 = new scaleway.VpcPublicGatewayDhcp("dhcp01", {subnet: "192.168.1.0/24"});
const pn01 = new scaleway.VpcPrivateNetwork("pn01", {});
const gn01 = new scaleway.VpcGatewayNetwork("gn01", {
    gatewayId: pg01.id,
    privateNetworkId: pn01.id,
    dhcpId: dhcp01.id,
    cleanupDhcp: true,
    enableMasquerade: true,
}, {
    dependsOn: [pn01],
});
const mainVpcPublicGatewayPatRule = new scaleway.VpcPublicGatewayPatRule("mainVpcPublicGatewayPatRule", {
    gatewayId: pg01.id,
    privateIp: dhcp01.address,
    privatePort: 42,
    publicPort: 42,
    protocol: "both",
}, {
    dependsOn: [
        gn01,
        pn01,
    ],
});
const mainVpcPublicPatRule = scaleway.getVpcPublicPatRuleOutput({
    patRuleId: mainVpcPublicGatewayPatRule.id,
});

resources:
  pg01:
    type: scaleway:VpcPublicGateway
    properties:
      type: VPC-GW-S
  dhcp01:
    type: scaleway:VpcPublicGatewayDhcp
    properties:
      subnet: 192.168.1.0/24
  pn01:
    type: scaleway:VpcPrivateNetwork
  gn01:
    type: scaleway:VpcGatewayNetwork
    properties:
      gatewayId: ${pg01.id}
      privateNetworkId: ${pn01.id}
      dhcpId: ${dhcp01.id}
      cleanupDhcp: true
      enableMasquerade: true
    options:
      dependson:
        - ${pn01}
  mainVpcPublicGatewayPatRule:
    type: scaleway:VpcPublicGatewayPatRule
    properties:
      gatewayId: ${pg01.id}
      privateIp: ${dhcp01.address}
      privatePort: 42
      publicPort: 42
      protocol: both
    options:
      dependson:
        - ${gn01}
        - ${pn01}
variables:
  mainVpcPublicPatRule:
    fn::invoke:
      Function: scaleway:getVpcPublicPatRule
      Arguments:
        patRuleId: ${mainVpcPublicGatewayPatRule.id}