Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Scaleway
  3. API Docs
  4. getVpcPublicPatRule
Scaleway v1.25.0 published on Saturday, Mar 22, 2025 by pulumiverse
pulumiverse/pulumi-scaleway

scaleway.getVpcPublicPatRule

Explore with Pulumi AI

scaleway logo
Scaleway v1.25.0 published on Saturday, Mar 22, 2025 by pulumiverse
pulumiverse/pulumi-scaleway
    Deprecated: scaleway.index/getvpcpublicpatrule.getVpcPublicPatRule has been deprecated in favor of scaleway.network/getpublicgatewaypatrule.getPublicGatewayPatRule

    Gets information about a Public Gateway PAT rule. For further information, please see the API documentation.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumi/scaleway";
import * as scaleway from "@pulumiverse/scaleway";

const sg01 = new scaleway.instance.SecurityGroup("sg01", {
    inboundDefaultPolicy: "drop",
    outboundDefaultPolicy: "accept",
    inboundRules: [{
        action: "accept",
        port: 22,
        protocol: "TCP",
    }],
});
const srv01 = new scaleway.instance.Server("srv01", {
    name: "my-server",
    type: "PLAY2-NANO",
    image: "ubuntu_jammy",
    securityGroupId: sg01.id,
});
const pn01 = new scaleway.network.PrivateNetwork("pn01", {name: "my-pn"});
const pnic01 = new scaleway.instance.PrivateNic("pnic01", {
    serverId: srv01.id,
    privateNetworkId: pn01.id,
});
const dhcp01 = new scaleway.network.PublicGatewayDhcp("dhcp01", {subnet: "192.168.0.0/24"});
const ip01 = new scaleway.network.PublicGatewayIp("ip01", {});
const pg01 = new scaleway.network.PublicGateway("pg01", {
    name: "my-pg",
    type: "VPC-GW-S",
    ipId: ip01.id,
});
const gn01 = new scaleway.network.GatewayNetwork("gn01", {
    gatewayId: pg01.id,
    privateNetworkId: pn01.id,
    dhcpId: dhcp01.id,
    cleanupDhcp: true,
    enableMasquerade: true,
});
const rsv01 = new scaleway.network.PublicGatewayDhcpReservation("rsv01", {
    gatewayNetworkId: gn01.id,
    macAddress: pnic01.macAddress,
    ipAddress: "192.168.0.7",
});
const pat01 = new scaleway.network.PublicGatewayPatRule("pat01", {
    gatewayId: pg01.id,
    privateIp: rsv01.ipAddress,
    privatePort: 22,
    publicPort: 2202,
    protocol: "tcp",
});
const main = scaleway.network.getPublicGatewayPatRuleOutput({
    patRuleId: pat01.id,
});

    import pulumi
import pulumi_scaleway as scaleway
import pulumiverse_scaleway as scaleway

sg01 = scaleway.instance.SecurityGroup("sg01",
    inbound_default_policy="drop",
    outbound_default_policy="accept",
    inbound_rules=[{
        "action": "accept",
        "port": 22,
        "protocol": "TCP",
    }])
srv01 = scaleway.instance.Server("srv01",
    name="my-server",
    type="PLAY2-NANO",
    image="ubuntu_jammy",
    security_group_id=sg01.id)
pn01 = scaleway.network.PrivateNetwork("pn01", name="my-pn")
pnic01 = scaleway.instance.PrivateNic("pnic01",
    server_id=srv01.id,
    private_network_id=pn01.id)
dhcp01 = scaleway.network.PublicGatewayDhcp("dhcp01", subnet="192.168.0.0/24")
ip01 = scaleway.network.PublicGatewayIp("ip01")
pg01 = scaleway.network.PublicGateway("pg01",
    name="my-pg",
    type="VPC-GW-S",
    ip_id=ip01.id)
gn01 = scaleway.network.GatewayNetwork("gn01",
    gateway_id=pg01.id,
    private_network_id=pn01.id,
    dhcp_id=dhcp01.id,
    cleanup_dhcp=True,
    enable_masquerade=True)
rsv01 = scaleway.network.PublicGatewayDhcpReservation("rsv01",
    gateway_network_id=gn01.id,
    mac_address=pnic01.mac_address,
    ip_address="192.168.0.7")
pat01 = scaleway.network.PublicGatewayPatRule("pat01",
    gateway_id=pg01.id,
    private_ip=rsv01.ip_address,
    private_port=22,
    public_port=2202,
    protocol="tcp")
main = scaleway.network.get_public_gateway_pat_rule_output(pat_rule_id=pat01.id)

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/instance"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/network"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		sg01, err := instance.NewSecurityGroup(ctx, "sg01", &instance.SecurityGroupArgs{
			InboundDefaultPolicy:  pulumi.String("drop"),
			OutboundDefaultPolicy: pulumi.String("accept"),
			InboundRules: instance.SecurityGroupInboundRuleArray{
				&instance.SecurityGroupInboundRuleArgs{
					Action:   pulumi.String("accept"),
					Port:     pulumi.Int(22),
					Protocol: pulumi.String("TCP"),
				},
			},
		})
		if err != nil {
			return err
		}
		srv01, err := instance.NewServer(ctx, "srv01", &instance.ServerArgs{
			Name:            pulumi.String("my-server"),
			Type:            pulumi.String("PLAY2-NANO"),
			Image:           pulumi.String("ubuntu_jammy"),
			SecurityGroupId: sg01.ID(),
		})
		if err != nil {
			return err
		}
		pn01, err := network.NewPrivateNetwork(ctx, "pn01", &network.PrivateNetworkArgs{
			Name: pulumi.String("my-pn"),
		})
		if err != nil {
			return err
		}
		pnic01, err := instance.NewPrivateNic(ctx, "pnic01", &instance.PrivateNicArgs{
			ServerId:         srv01.ID(),
			PrivateNetworkId: pn01.ID(),
		})
		if err != nil {
			return err
		}
		dhcp01, err := network.NewPublicGatewayDhcp(ctx, "dhcp01", &network.PublicGatewayDhcpArgs{
			Subnet: pulumi.String("192.168.0.0/24"),
		})
		if err != nil {
			return err
		}
		ip01, err := network.NewPublicGatewayIp(ctx, "ip01", nil)
		if err != nil {
			return err
		}
		pg01, err := network.NewPublicGateway(ctx, "pg01", &network.PublicGatewayArgs{
			Name: pulumi.String("my-pg"),
			Type: pulumi.String("VPC-GW-S"),
			IpId: ip01.ID(),
		})
		if err != nil {
			return err
		}
		gn01, err := network.NewGatewayNetwork(ctx, "gn01", &network.GatewayNetworkArgs{
			GatewayId:        pg01.ID(),
			PrivateNetworkId: pn01.ID(),
			DhcpId:           dhcp01.ID(),
			CleanupDhcp:      pulumi.Bool(true),
			EnableMasquerade: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		rsv01, err := network.NewPublicGatewayDhcpReservation(ctx, "rsv01", &network.PublicGatewayDhcpReservationArgs{
			GatewayNetworkId: gn01.ID(),
			MacAddress:       pnic01.MacAddress,
			IpAddress:        pulumi.String("192.168.0.7"),
		})
		if err != nil {
			return err
		}
		pat01, err := network.NewPublicGatewayPatRule(ctx, "pat01", &network.PublicGatewayPatRuleArgs{
			GatewayId:   pg01.ID(),
			PrivateIp:   rsv01.IpAddress,
			PrivatePort: pulumi.Int(22),
			PublicPort:  pulumi.Int(2202),
			Protocol:    pulumi.String("tcp"),
		})
		if err != nil {
			return err
		}
		_ = network.LookupPublicGatewayPatRuleOutput(ctx, network.GetPublicGatewayPatRuleOutputArgs{
			PatRuleId: pat01.ID(),
		}, nil)
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumi.Scaleway;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var sg01 = new Scaleway.Instance.SecurityGroup("sg01", new()
    {
        InboundDefaultPolicy = "drop",
        OutboundDefaultPolicy = "accept",
        InboundRules = new[]
        {
            new Scaleway.Instance.Inputs.SecurityGroupInboundRuleArgs
            {
                Action = "accept",
                Port = 22,
                Protocol = "TCP",
            },
        },
    });

    var srv01 = new Scaleway.Instance.Server("srv01", new()
    {
        Name = "my-server",
        Type = "PLAY2-NANO",
        Image = "ubuntu_jammy",
        SecurityGroupId = sg01.Id,
    });

    var pn01 = new Scaleway.Network.PrivateNetwork("pn01", new()
    {
        Name = "my-pn",
    });

    var pnic01 = new Scaleway.Instance.PrivateNic("pnic01", new()
    {
        ServerId = srv01.Id,
        PrivateNetworkId = pn01.Id,
    });

    var dhcp01 = new Scaleway.Network.PublicGatewayDhcp("dhcp01", new()
    {
        Subnet = "192.168.0.0/24",
    });

    var ip01 = new Scaleway.Network.PublicGatewayIp("ip01");

    var pg01 = new Scaleway.Network.PublicGateway("pg01", new()
    {
        Name = "my-pg",
        Type = "VPC-GW-S",
        IpId = ip01.Id,
    });

    var gn01 = new Scaleway.Network.GatewayNetwork("gn01", new()
    {
        GatewayId = pg01.Id,
        PrivateNetworkId = pn01.Id,
        DhcpId = dhcp01.Id,
        CleanupDhcp = true,
        EnableMasquerade = true,
    });

    var rsv01 = new Scaleway.Network.PublicGatewayDhcpReservation("rsv01", new()
    {
        GatewayNetworkId = gn01.Id,
        MacAddress = pnic01.MacAddress,
        IpAddress = "192.168.0.7",
    });

    var pat01 = new Scaleway.Network.PublicGatewayPatRule("pat01", new()
    {
        GatewayId = pg01.Id,
        PrivateIp = rsv01.IpAddress,
        PrivatePort = 22,
        PublicPort = 2202,
        Protocol = "tcp",
    });

    var main = Scaleway.Network.GetPublicGatewayPatRule.Invoke(new()
    {
        PatRuleId = pat01.Id,
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.instance.SecurityGroup;
import com.pulumi.scaleway.instance.SecurityGroupArgs;
import com.pulumi.scaleway.instance.inputs.SecurityGroupInboundRuleArgs;
import com.pulumi.scaleway.instance.Server;
import com.pulumi.scaleway.instance.ServerArgs;
import com.pulumi.scaleway.network.PrivateNetwork;
import com.pulumi.scaleway.network.PrivateNetworkArgs;
import com.pulumi.scaleway.instance.PrivateNic;
import com.pulumi.scaleway.instance.PrivateNicArgs;
import com.pulumi.scaleway.network.PublicGatewayDhcp;
import com.pulumi.scaleway.network.PublicGatewayDhcpArgs;
import com.pulumi.scaleway.network.PublicGatewayIp;
import com.pulumi.scaleway.network.PublicGateway;
import com.pulumi.scaleway.network.PublicGatewayArgs;
import com.pulumi.scaleway.network.GatewayNetwork;
import com.pulumi.scaleway.network.GatewayNetworkArgs;
import com.pulumi.scaleway.network.PublicGatewayDhcpReservation;
import com.pulumi.scaleway.network.PublicGatewayDhcpReservationArgs;
import com.pulumi.scaleway.network.PublicGatewayPatRule;
import com.pulumi.scaleway.network.PublicGatewayPatRuleArgs;
import com.pulumi.scaleway.network.NetworkFunctions;
import com.pulumi.scaleway.network.inputs.GetPublicGatewayPatRuleArgs;
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 sg01 = new SecurityGroup("sg01", SecurityGroupArgs.builder()
            .inboundDefaultPolicy("drop")
            .outboundDefaultPolicy("accept")
            .inboundRules(SecurityGroupInboundRuleArgs.builder()
                .action("accept")
                .port(22)
                .protocol("TCP")
                .build())
            .build());

        var srv01 = new Server("srv01", ServerArgs.builder()
            .name("my-server")
            .type("PLAY2-NANO")
            .image("ubuntu_jammy")
            .securityGroupId(sg01.id())
            .build());

        var pn01 = new PrivateNetwork("pn01", PrivateNetworkArgs.builder()
            .name("my-pn")
            .build());

        var pnic01 = new PrivateNic("pnic01", PrivateNicArgs.builder()
            .serverId(srv01.id())
            .privateNetworkId(pn01.id())
            .build());

        var dhcp01 = new PublicGatewayDhcp("dhcp01", PublicGatewayDhcpArgs.builder()
            .subnet("192.168.0.0/24")
            .build());

        var ip01 = new PublicGatewayIp("ip01");

        var pg01 = new PublicGateway("pg01", PublicGatewayArgs.builder()
            .name("my-pg")
            .type("VPC-GW-S")
            .ipId(ip01.id())
            .build());

        var gn01 = new GatewayNetwork("gn01", GatewayNetworkArgs.builder()
            .gatewayId(pg01.id())
            .privateNetworkId(pn01.id())
            .dhcpId(dhcp01.id())
            .cleanupDhcp(true)
            .enableMasquerade(true)
            .build());

        var rsv01 = new PublicGatewayDhcpReservation("rsv01", PublicGatewayDhcpReservationArgs.builder()
            .gatewayNetworkId(gn01.id())
            .macAddress(pnic01.macAddress())
            .ipAddress("192.168.0.7")
            .build());

        var pat01 = new PublicGatewayPatRule("pat01", PublicGatewayPatRuleArgs.builder()
            .gatewayId(pg01.id())
            .privateIp(rsv01.ipAddress())
            .privatePort(22)
            .publicPort(2202)
            .protocol("tcp")
            .build());

        final var main = NetworkFunctions.getPublicGatewayPatRule(GetPublicGatewayPatRuleArgs.builder()
            .patRuleId(pat01.id())
            .build());

    }
}

    resources:
  sg01:
    type: scaleway:instance:SecurityGroup
    properties:
      inboundDefaultPolicy: drop
      outboundDefaultPolicy: accept
      inboundRules:
        - action: accept
          port: 22
          protocol: TCP
  srv01:
    type: scaleway:instance:Server
    properties:
      name: my-server
      type: PLAY2-NANO
      image: ubuntu_jammy
      securityGroupId: ${sg01.id}
  pnic01:
    type: scaleway:instance:PrivateNic
    properties:
      serverId: ${srv01.id}
      privateNetworkId: ${pn01.id}
  pn01:
    type: scaleway:network:PrivateNetwork
    properties:
      name: my-pn
  dhcp01:
    type: scaleway:network:PublicGatewayDhcp
    properties:
      subnet: 192.168.0.0/24
  ip01:
    type: scaleway:network:PublicGatewayIp
  pg01:
    type: scaleway:network:PublicGateway
    properties:
      name: my-pg
      type: VPC-GW-S
      ipId: ${ip01.id}
  gn01:
    type: scaleway:network:GatewayNetwork
    properties:
      gatewayId: ${pg01.id}
      privateNetworkId: ${pn01.id}
      dhcpId: ${dhcp01.id}
      cleanupDhcp: true
      enableMasquerade: true
  rsv01:
    type: scaleway:network:PublicGatewayDhcpReservation
    properties:
      gatewayNetworkId: ${gn01.id}
      macAddress: ${pnic01.macAddress}
      ipAddress: 192.168.0.7
  pat01:
    type: scaleway:network:PublicGatewayPatRule
    properties:
      gatewayId: ${pg01.id}
      privateIp: ${rsv01.ipAddress}
      privatePort: 22
      publicPort: 2202
      protocol: tcp
variables:
  main:
    fn::invoke:
      function: scaleway:network:getPublicGatewayPatRule
      arguments:
        patRuleId: ${pat01.id}

    Using getVpcPublicPatRule

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function getVpcPublicPatRule(args: GetVpcPublicPatRuleArgs, opts?: InvokeOptions): Promise<GetVpcPublicPatRuleResult>
function getVpcPublicPatRuleOutput(args: GetVpcPublicPatRuleOutputArgs, opts?: InvokeOptions): Output<GetVpcPublicPatRuleResult>
    def get_vpc_public_pat_rule(pat_rule_id: Optional[str] = None,
                            zone: Optional[str] = None,
                            opts: Optional[InvokeOptions] = None) -> GetVpcPublicPatRuleResult
def get_vpc_public_pat_rule_output(pat_rule_id: Optional[pulumi.Input[str]] = None,
                            zone: Optional[pulumi.Input[str]] = None,
                            opts: Optional[InvokeOptions] = None) -> Output[GetVpcPublicPatRuleResult]
    func GetVpcPublicPatRule(ctx *Context, args *GetVpcPublicPatRuleArgs, opts ...InvokeOption) (*GetVpcPublicPatRuleResult, error)
func GetVpcPublicPatRuleOutput(ctx *Context, args *GetVpcPublicPatRuleOutputArgs, opts ...InvokeOption) GetVpcPublicPatRuleResultOutput

    > Note: This function is named GetVpcPublicPatRule in the Go SDK.

    public static class GetVpcPublicPatRule 
{
    public static Task<GetVpcPublicPatRuleResult> InvokeAsync(GetVpcPublicPatRuleArgs args, InvokeOptions? opts = null)
    public static Output<GetVpcPublicPatRuleResult> Invoke(GetVpcPublicPatRuleInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<GetVpcPublicPatRuleResult> getVpcPublicPatRule(GetVpcPublicPatRuleArgs args, InvokeOptions options)
public static Output<GetVpcPublicPatRuleResult> getVpcPublicPatRule(GetVpcPublicPatRuleArgs args, InvokeOptions options)

    fn::invoke:
  function: scaleway:index/getVpcPublicPatRule:getVpcPublicPatRule
  arguments:
    # arguments dictionary

    The following arguments are supported:

    PatRuleId string
    The ID of the PAT rule to retrieve
    Zone string
    zone) The zone in which the rule exists.
    PatRuleId string
    The ID of the PAT rule to retrieve
    Zone string
    zone) The zone in which the rule exists.
    patRuleId String
    The ID of the PAT rule to retrieve
    zone String
    zone) The zone in which the rule exists.
    patRuleId string
    The ID of the PAT rule to retrieve
    zone string
    zone) The zone in which the rule exists.
    pat_rule_id str
    The ID of the PAT rule to retrieve
    zone str
    zone) The zone in which the rule exists.
    patRuleId String
    The ID of the PAT rule to retrieve
    zone String
    zone) The zone in which the rule exists.

    getVpcPublicPatRule Result

    The following output properties are available:

    CreatedAt string
    GatewayId string
    The ID of the Public Gateway.
    Id string
    The provider-assigned unique ID for this managed resource.
    OrganizationId string
    PatRuleId string
    PrivateIp string
    The private IP address to forward data to.
    PrivatePort int
    The private port to translate to.
    Protocol string
    The protocol the rule should apply to. Possible values are both, tcp and udp.
    PublicPort int
    The public port to listen on.
    UpdatedAt string
    Zone string
    CreatedAt string
    GatewayId string
    The ID of the Public Gateway.
    Id string
    The provider-assigned unique ID for this managed resource.
    OrganizationId string
    PatRuleId string
    PrivateIp string
    The private IP address to forward data to.
    PrivatePort int
    The private port to translate to.
    Protocol string
    The protocol the rule should apply to. Possible values are both, tcp and udp.
    PublicPort int
    The public port to listen on.
    UpdatedAt string
    Zone string
    createdAt String
    gatewayId String
    The ID of the Public Gateway.
    id String
    The provider-assigned unique ID for this managed resource.
    organizationId String
    patRuleId String
    privateIp String
    The private IP address to forward data to.
    privatePort Integer
    The private port to translate to.
    protocol String
    The protocol the rule should apply to. Possible values are both, tcp and udp.
    publicPort Integer
    The public port to listen on.
    updatedAt String
    zone String
    createdAt string
    gatewayId string
    The ID of the Public Gateway.
    id string
    The provider-assigned unique ID for this managed resource.
    organizationId string
    patRuleId string
    privateIp string
    The private IP address to forward data to.
    privatePort number
    The private port to translate to.
    protocol string
    The protocol the rule should apply to. Possible values are both, tcp and udp.
    publicPort number
    The public port to listen on.
    updatedAt string
    zone string
    created_at str
    gateway_id str
    The ID of the Public Gateway.
    id str
    The provider-assigned unique ID for this managed resource.
    organization_id str
    pat_rule_id str
    private_ip str
    The private IP address to forward data to.
    private_port int
    The private port to translate to.
    protocol str
    The protocol the rule should apply to. Possible values are both, tcp and udp.
    public_port int
    The public port to listen on.
    updated_at str
    zone str
    createdAt String
    gatewayId String
    The ID of the Public Gateway.
    id String
    The provider-assigned unique ID for this managed resource.
    organizationId String
    patRuleId String
    privateIp String
    The private IP address to forward data to.
    privatePort Number
    The private port to translate to.
    protocol String
    The protocol the rule should apply to. Possible values are both, tcp and udp.
    publicPort Number
    The public port to listen on.
    updatedAt String
    zone String

    Package Details

    Repository
    scaleway pulumiverse/pulumi-scaleway
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the scaleway Terraform Provider.
    scaleway logo
    Scaleway v1.25.0 published on Saturday, Mar 22, 2025 by pulumiverse
    pulumiverse/pulumi-scaleway