Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Scaleway
  3. API Docs
  4. network
  5. getPublicGatewayDhcpReservation
Scaleway v1.26.0 published on Friday, Mar 28, 2025 by pulumiverse
pulumiverse/pulumi-scaleway

scaleway.network.getPublicGatewayDhcpReservation

Explore with Pulumi AI

Scaleway v1.26.0 published on Friday, Mar 28, 2025 by pulumiverse
pulumiverse/pulumi-scaleway

Important: The data source scaleway.network.PublicGatewayDhcpReservation has been deprecated and will no longer be supported. In 2023, DHCP functionality was moved from Public Gateways to Private Networks, DHCP resources are now no longer needed. You can use IPAM to manage your IPs. For more information, please refer to the dedicated guide.

Gets information about a DHCP entry. For further information, please see the API documentation.

Example Dynamic

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

const main = new scaleway.network.PrivateNetwork("main", {});
const mainServer = new scaleway.instance.Server("main", {
    image: "ubuntu_jammy",
    type: "DEV1-S",
    zone: "fr-par-1",
});
const mainPrivateNic = new scaleway.instance.PrivateNic("main", {
    serverId: mainServer.id,
    privateNetworkId: main.id,
});
const mainPublicGatewayIp = new scaleway.network.PublicGatewayIp("main", {});
const mainPublicGatewayDhcp = new scaleway.network.PublicGatewayDhcp("main", {subnet: "192.168.1.0/24"});
const mainPublicGateway = new scaleway.network.PublicGateway("main", {
    name: "foobar",
    type: "VPC-GW-S",
    ipId: mainPublicGatewayIp.id,
});
const mainGatewayNetwork = new scaleway.network.GatewayNetwork("main", {
    gatewayId: mainPublicGateway.id,
    privateNetworkId: main.id,
    dhcpId: mainPublicGatewayDhcp.id,
    cleanupDhcp: true,
    enableMasquerade: true,
});
//# Retrieve the dynamic entries generated by mac address & gateway network
const byMacAddressAndGwNetwork = scaleway.network.getPublicGatewayDhcpReservationOutput({
    macAddress: mainPrivateNic.macAddress,
    gatewayNetworkId: mainGatewayNetwork.id,
});
Copy
import pulumi
import pulumi_scaleway as scaleway
import pulumiverse_scaleway as scaleway

main = scaleway.network.PrivateNetwork("main")
main_server = scaleway.instance.Server("main",
    image="ubuntu_jammy",
    type="DEV1-S",
    zone="fr-par-1")
main_private_nic = scaleway.instance.PrivateNic("main",
    server_id=main_server.id,
    private_network_id=main.id)
main_public_gateway_ip = scaleway.network.PublicGatewayIp("main")
main_public_gateway_dhcp = scaleway.network.PublicGatewayDhcp("main", subnet="192.168.1.0/24")
main_public_gateway = scaleway.network.PublicGateway("main",
    name="foobar",
    type="VPC-GW-S",
    ip_id=main_public_gateway_ip.id)
main_gateway_network = scaleway.network.GatewayNetwork("main",
    gateway_id=main_public_gateway.id,
    private_network_id=main.id,
    dhcp_id=main_public_gateway_dhcp.id,
    cleanup_dhcp=True,
    enable_masquerade=True)
## Retrieve the dynamic entries generated by mac address & gateway network
by_mac_address_and_gw_network = scaleway.network.get_public_gateway_dhcp_reservation_output(mac_address=main_private_nic.mac_address,
    gateway_network_id=main_gateway_network.id)
Copy
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 {
		main, err := network.NewPrivateNetwork(ctx, "main", nil)
		if err != nil {
			return err
		}
		mainServer, err := instance.NewServer(ctx, "main", &instance.ServerArgs{
			Image: pulumi.String("ubuntu_jammy"),
			Type:  pulumi.String("DEV1-S"),
			Zone:  pulumi.String("fr-par-1"),
		})
		if err != nil {
			return err
		}
		mainPrivateNic, err := instance.NewPrivateNic(ctx, "main", &instance.PrivateNicArgs{
			ServerId:         mainServer.ID(),
			PrivateNetworkId: main.ID(),
		})
		if err != nil {
			return err
		}
		mainPublicGatewayIp, err := network.NewPublicGatewayIp(ctx, "main", nil)
		if err != nil {
			return err
		}
		mainPublicGatewayDhcp, err := network.NewPublicGatewayDhcp(ctx, "main", &network.PublicGatewayDhcpArgs{
			Subnet: pulumi.String("192.168.1.0/24"),
		})
		if err != nil {
			return err
		}
		mainPublicGateway, err := network.NewPublicGateway(ctx, "main", &network.PublicGatewayArgs{
			Name: pulumi.String("foobar"),
			Type: pulumi.String("VPC-GW-S"),
			IpId: mainPublicGatewayIp.ID(),
		})
		if err != nil {
			return err
		}
		mainGatewayNetwork, err := network.NewGatewayNetwork(ctx, "main", &network.GatewayNetworkArgs{
			GatewayId:        mainPublicGateway.ID(),
			PrivateNetworkId: main.ID(),
			DhcpId:           mainPublicGatewayDhcp.ID(),
			CleanupDhcp:      pulumi.Bool(true),
			EnableMasquerade: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// # Retrieve the dynamic entries generated by mac address & gateway network
		_ = network.LookupPublicGatewayDhcpReservationOutput(ctx, network.GetPublicGatewayDhcpReservationOutputArgs{
			MacAddress:       mainPrivateNic.MacAddress,
			GatewayNetworkId: mainGatewayNetwork.ID(),
		}, nil)
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumi.Scaleway;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.Network.PrivateNetwork("main");

    var mainServer = new Scaleway.Instance.Server("main", new()
    {
        Image = "ubuntu_jammy",
        Type = "DEV1-S",
        Zone = "fr-par-1",
    });

    var mainPrivateNic = new Scaleway.Instance.PrivateNic("main", new()
    {
        ServerId = mainServer.Id,
        PrivateNetworkId = main.Id,
    });

    var mainPublicGatewayIp = new Scaleway.Network.PublicGatewayIp("main");

    var mainPublicGatewayDhcp = new Scaleway.Network.PublicGatewayDhcp("main", new()
    {
        Subnet = "192.168.1.0/24",
    });

    var mainPublicGateway = new Scaleway.Network.PublicGateway("main", new()
    {
        Name = "foobar",
        Type = "VPC-GW-S",
        IpId = mainPublicGatewayIp.Id,
    });

    var mainGatewayNetwork = new Scaleway.Network.GatewayNetwork("main", new()
    {
        GatewayId = mainPublicGateway.Id,
        PrivateNetworkId = main.Id,
        DhcpId = mainPublicGatewayDhcp.Id,
        CleanupDhcp = true,
        EnableMasquerade = true,
    });

    //# Retrieve the dynamic entries generated by mac address & gateway network
    var byMacAddressAndGwNetwork = Scaleway.Network.GetPublicGatewayDhcpReservation.Invoke(new()
    {
        MacAddress = mainPrivateNic.MacAddress,
        GatewayNetworkId = mainGatewayNetwork.Id,
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.network.PrivateNetwork;
import com.pulumi.scaleway.instance.Server;
import com.pulumi.scaleway.instance.ServerArgs;
import com.pulumi.scaleway.instance.PrivateNic;
import com.pulumi.scaleway.instance.PrivateNicArgs;
import com.pulumi.scaleway.network.PublicGatewayIp;
import com.pulumi.scaleway.network.PublicGatewayDhcp;
import com.pulumi.scaleway.network.PublicGatewayDhcpArgs;
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.NetworkFunctions;
import com.pulumi.scaleway.network.inputs.GetPublicGatewayDhcpReservationArgs;
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 main = new PrivateNetwork("main");

        var mainServer = new Server("mainServer", ServerArgs.builder()
            .image("ubuntu_jammy")
            .type("DEV1-S")
            .zone("fr-par-1")
            .build());

        var mainPrivateNic = new PrivateNic("mainPrivateNic", PrivateNicArgs.builder()
            .serverId(mainServer.id())
            .privateNetworkId(main.id())
            .build());

        var mainPublicGatewayIp = new PublicGatewayIp("mainPublicGatewayIp");

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

        var mainPublicGateway = new PublicGateway("mainPublicGateway", PublicGatewayArgs.builder()
            .name("foobar")
            .type("VPC-GW-S")
            .ipId(mainPublicGatewayIp.id())
            .build());

        var mainGatewayNetwork = new GatewayNetwork("mainGatewayNetwork", GatewayNetworkArgs.builder()
            .gatewayId(mainPublicGateway.id())
            .privateNetworkId(main.id())
            .dhcpId(mainPublicGatewayDhcp.id())
            .cleanupDhcp(true)
            .enableMasquerade(true)
            .build());

        //# Retrieve the dynamic entries generated by mac address & gateway network
        final var byMacAddressAndGwNetwork = NetworkFunctions.getPublicGatewayDhcpReservation(GetPublicGatewayDhcpReservationArgs.builder()
            .macAddress(mainPrivateNic.macAddress())
            .gatewayNetworkId(mainGatewayNetwork.id())
            .build());

    }
}
Copy
resources:
  main:
    type: scaleway:network:PrivateNetwork
  mainServer:
    type: scaleway:instance:Server
    name: main
    properties:
      image: ubuntu_jammy
      type: DEV1-S
      zone: fr-par-1
  mainPrivateNic:
    type: scaleway:instance:PrivateNic
    name: main
    properties:
      serverId: ${mainServer.id}
      privateNetworkId: ${main.id}
  mainPublicGatewayIp:
    type: scaleway:network:PublicGatewayIp
    name: main
  mainPublicGatewayDhcp:
    type: scaleway:network:PublicGatewayDhcp
    name: main
    properties:
      subnet: 192.168.1.0/24
  mainPublicGateway:
    type: scaleway:network:PublicGateway
    name: main
    properties:
      name: foobar
      type: VPC-GW-S
      ipId: ${mainPublicGatewayIp.id}
  mainGatewayNetwork:
    type: scaleway:network:GatewayNetwork
    name: main
    properties:
      gatewayId: ${mainPublicGateway.id}
      privateNetworkId: ${main.id}
      dhcpId: ${mainPublicGatewayDhcp.id}
      cleanupDhcp: true
      enableMasquerade: true
variables:
  ## Retrieve the dynamic entries generated by mac address & gateway network
  byMacAddressAndGwNetwork:
    fn::invoke:
      function: scaleway:network:getPublicGatewayDhcpReservation
      arguments:
        macAddress: ${mainPrivateNic.macAddress}
        gatewayNetworkId: ${mainGatewayNetwork.id}
Copy

Example Static and PAT Rule

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

const main = new scaleway.network.PrivateNetwork("main", {});
const mainSecurityGroup = new scaleway.instance.SecurityGroup("main", {
    inboundDefaultPolicy: "drop",
    outboundDefaultPolicy: "accept",
    inboundRules: [{
        action: "accept",
        port: 22,
    }],
});
const mainServer = new scaleway.instance.Server("main", {
    image: "ubuntu_jammy",
    type: "DEV1-S",
    zone: "fr-par-1",
    securityGroupId: mainSecurityGroup.id,
});
const mainPrivateNic = new scaleway.instance.PrivateNic("main", {
    serverId: mainServer.id,
    privateNetworkId: main.id,
});
const mainPublicGatewayIp = new scaleway.network.PublicGatewayIp("main", {});
const mainPublicGatewayDhcp = new scaleway.network.PublicGatewayDhcp("main", {subnet: "192.168.1.0/24"});
const mainPublicGateway = new scaleway.network.PublicGateway("main", {
    name: "foobar",
    type: "VPC-GW-S",
    ipId: mainPublicGatewayIp.id,
});
const mainGatewayNetwork = new scaleway.network.GatewayNetwork("main", {
    gatewayId: mainPublicGateway.id,
    privateNetworkId: main.id,
    dhcpId: mainPublicGatewayDhcp.id,
    cleanupDhcp: true,
    enableMasquerade: true,
});
const mainPublicGatewayDhcpReservation = new scaleway.network.PublicGatewayDhcpReservation("main", {
    gatewayNetworkId: mainGatewayNetwork.id,
    macAddress: mainPrivateNic.macAddress,
    ipAddress: "192.168.1.4",
});
//## VPC PAT RULE
const mainPublicGatewayPatRule = new scaleway.network.PublicGatewayPatRule("main", {
    gatewayId: mainPublicGateway.id,
    privateIp: mainPublicGatewayDhcpReservation.ipAddress,
    privatePort: 22,
    publicPort: 2222,
    protocol: "tcp",
});
const byId = scaleway.network.getPublicGatewayDhcpReservationOutput({
    reservationId: mainPublicGatewayDhcpReservation.id,
});
Copy
import pulumi
import pulumi_scaleway as scaleway
import pulumiverse_scaleway as scaleway

main = scaleway.network.PrivateNetwork("main")
main_security_group = scaleway.instance.SecurityGroup("main",
    inbound_default_policy="drop",
    outbound_default_policy="accept",
    inbound_rules=[{
        "action": "accept",
        "port": 22,
    }])
main_server = scaleway.instance.Server("main",
    image="ubuntu_jammy",
    type="DEV1-S",
    zone="fr-par-1",
    security_group_id=main_security_group.id)
main_private_nic = scaleway.instance.PrivateNic("main",
    server_id=main_server.id,
    private_network_id=main.id)
main_public_gateway_ip = scaleway.network.PublicGatewayIp("main")
main_public_gateway_dhcp = scaleway.network.PublicGatewayDhcp("main", subnet="192.168.1.0/24")
main_public_gateway = scaleway.network.PublicGateway("main",
    name="foobar",
    type="VPC-GW-S",
    ip_id=main_public_gateway_ip.id)
main_gateway_network = scaleway.network.GatewayNetwork("main",
    gateway_id=main_public_gateway.id,
    private_network_id=main.id,
    dhcp_id=main_public_gateway_dhcp.id,
    cleanup_dhcp=True,
    enable_masquerade=True)
main_public_gateway_dhcp_reservation = scaleway.network.PublicGatewayDhcpReservation("main",
    gateway_network_id=main_gateway_network.id,
    mac_address=main_private_nic.mac_address,
    ip_address="192.168.1.4")
### VPC PAT RULE
main_public_gateway_pat_rule = scaleway.network.PublicGatewayPatRule("main",
    gateway_id=main_public_gateway.id,
    private_ip=main_public_gateway_dhcp_reservation.ip_address,
    private_port=22,
    public_port=2222,
    protocol="tcp")
by_id = scaleway.network.get_public_gateway_dhcp_reservation_output(reservation_id=main_public_gateway_dhcp_reservation.id)
Copy
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 {
		main, err := network.NewPrivateNetwork(ctx, "main", nil)
		if err != nil {
			return err
		}
		mainSecurityGroup, err := instance.NewSecurityGroup(ctx, "main", &instance.SecurityGroupArgs{
			InboundDefaultPolicy:  pulumi.String("drop"),
			OutboundDefaultPolicy: pulumi.String("accept"),
			InboundRules: instance.SecurityGroupInboundRuleArray{
				&instance.SecurityGroupInboundRuleArgs{
					Action: pulumi.String("accept"),
					Port:   pulumi.Int(22),
				},
			},
		})
		if err != nil {
			return err
		}
		mainServer, err := instance.NewServer(ctx, "main", &instance.ServerArgs{
			Image:           pulumi.String("ubuntu_jammy"),
			Type:            pulumi.String("DEV1-S"),
			Zone:            pulumi.String("fr-par-1"),
			SecurityGroupId: mainSecurityGroup.ID(),
		})
		if err != nil {
			return err
		}
		mainPrivateNic, err := instance.NewPrivateNic(ctx, "main", &instance.PrivateNicArgs{
			ServerId:         mainServer.ID(),
			PrivateNetworkId: main.ID(),
		})
		if err != nil {
			return err
		}
		mainPublicGatewayIp, err := network.NewPublicGatewayIp(ctx, "main", nil)
		if err != nil {
			return err
		}
		mainPublicGatewayDhcp, err := network.NewPublicGatewayDhcp(ctx, "main", &network.PublicGatewayDhcpArgs{
			Subnet: pulumi.String("192.168.1.0/24"),
		})
		if err != nil {
			return err
		}
		mainPublicGateway, err := network.NewPublicGateway(ctx, "main", &network.PublicGatewayArgs{
			Name: pulumi.String("foobar"),
			Type: pulumi.String("VPC-GW-S"),
			IpId: mainPublicGatewayIp.ID(),
		})
		if err != nil {
			return err
		}
		mainGatewayNetwork, err := network.NewGatewayNetwork(ctx, "main", &network.GatewayNetworkArgs{
			GatewayId:        mainPublicGateway.ID(),
			PrivateNetworkId: main.ID(),
			DhcpId:           mainPublicGatewayDhcp.ID(),
			CleanupDhcp:      pulumi.Bool(true),
			EnableMasquerade: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		mainPublicGatewayDhcpReservation, err := network.NewPublicGatewayDhcpReservation(ctx, "main", &network.PublicGatewayDhcpReservationArgs{
			GatewayNetworkId: mainGatewayNetwork.ID(),
			MacAddress:       mainPrivateNic.MacAddress,
			IpAddress:        pulumi.String("192.168.1.4"),
		})
		if err != nil {
			return err
		}
		// ## VPC PAT RULE
		_, err = network.NewPublicGatewayPatRule(ctx, "main", &network.PublicGatewayPatRuleArgs{
			GatewayId:   mainPublicGateway.ID(),
			PrivateIp:   mainPublicGatewayDhcpReservation.IpAddress,
			PrivatePort: pulumi.Int(22),
			PublicPort:  pulumi.Int(2222),
			Protocol:    pulumi.String("tcp"),
		})
		if err != nil {
			return err
		}
		_ = network.LookupPublicGatewayDhcpReservationOutput(ctx, network.GetPublicGatewayDhcpReservationOutputArgs{
			ReservationId: mainPublicGatewayDhcpReservation.ID(),
		}, nil)
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumi.Scaleway;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.Network.PrivateNetwork("main");

    var mainSecurityGroup = new Scaleway.Instance.SecurityGroup("main", new()
    {
        InboundDefaultPolicy = "drop",
        OutboundDefaultPolicy = "accept",
        InboundRules = new[]
        {
            new Scaleway.Instance.Inputs.SecurityGroupInboundRuleArgs
            {
                Action = "accept",
                Port = 22,
            },
        },
    });

    var mainServer = new Scaleway.Instance.Server("main", new()
    {
        Image = "ubuntu_jammy",
        Type = "DEV1-S",
        Zone = "fr-par-1",
        SecurityGroupId = mainSecurityGroup.Id,
    });

    var mainPrivateNic = new Scaleway.Instance.PrivateNic("main", new()
    {
        ServerId = mainServer.Id,
        PrivateNetworkId = main.Id,
    });

    var mainPublicGatewayIp = new Scaleway.Network.PublicGatewayIp("main");

    var mainPublicGatewayDhcp = new Scaleway.Network.PublicGatewayDhcp("main", new()
    {
        Subnet = "192.168.1.0/24",
    });

    var mainPublicGateway = new Scaleway.Network.PublicGateway("main", new()
    {
        Name = "foobar",
        Type = "VPC-GW-S",
        IpId = mainPublicGatewayIp.Id,
    });

    var mainGatewayNetwork = new Scaleway.Network.GatewayNetwork("main", new()
    {
        GatewayId = mainPublicGateway.Id,
        PrivateNetworkId = main.Id,
        DhcpId = mainPublicGatewayDhcp.Id,
        CleanupDhcp = true,
        EnableMasquerade = true,
    });

    var mainPublicGatewayDhcpReservation = new Scaleway.Network.PublicGatewayDhcpReservation("main", new()
    {
        GatewayNetworkId = mainGatewayNetwork.Id,
        MacAddress = mainPrivateNic.MacAddress,
        IpAddress = "192.168.1.4",
    });

    //## VPC PAT RULE
    var mainPublicGatewayPatRule = new Scaleway.Network.PublicGatewayPatRule("main", new()
    {
        GatewayId = mainPublicGateway.Id,
        PrivateIp = mainPublicGatewayDhcpReservation.IpAddress,
        PrivatePort = 22,
        PublicPort = 2222,
        Protocol = "tcp",
    });

    var byId = Scaleway.Network.GetPublicGatewayDhcpReservation.Invoke(new()
    {
        ReservationId = mainPublicGatewayDhcpReservation.Id,
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.network.PrivateNetwork;
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.instance.PrivateNic;
import com.pulumi.scaleway.instance.PrivateNicArgs;
import com.pulumi.scaleway.network.PublicGatewayIp;
import com.pulumi.scaleway.network.PublicGatewayDhcp;
import com.pulumi.scaleway.network.PublicGatewayDhcpArgs;
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.GetPublicGatewayDhcpReservationArgs;
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 main = new PrivateNetwork("main");

        var mainSecurityGroup = new SecurityGroup("mainSecurityGroup", SecurityGroupArgs.builder()
            .inboundDefaultPolicy("drop")
            .outboundDefaultPolicy("accept")
            .inboundRules(SecurityGroupInboundRuleArgs.builder()
                .action("accept")
                .port("22")
                .build())
            .build());

        var mainServer = new Server("mainServer", ServerArgs.builder()
            .image("ubuntu_jammy")
            .type("DEV1-S")
            .zone("fr-par-1")
            .securityGroupId(mainSecurityGroup.id())
            .build());

        var mainPrivateNic = new PrivateNic("mainPrivateNic", PrivateNicArgs.builder()
            .serverId(mainServer.id())
            .privateNetworkId(main.id())
            .build());

        var mainPublicGatewayIp = new PublicGatewayIp("mainPublicGatewayIp");

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

        var mainPublicGateway = new PublicGateway("mainPublicGateway", PublicGatewayArgs.builder()
            .name("foobar")
            .type("VPC-GW-S")
            .ipId(mainPublicGatewayIp.id())
            .build());

        var mainGatewayNetwork = new GatewayNetwork("mainGatewayNetwork", GatewayNetworkArgs.builder()
            .gatewayId(mainPublicGateway.id())
            .privateNetworkId(main.id())
            .dhcpId(mainPublicGatewayDhcp.id())
            .cleanupDhcp(true)
            .enableMasquerade(true)
            .build());

        var mainPublicGatewayDhcpReservation = new PublicGatewayDhcpReservation("mainPublicGatewayDhcpReservation", PublicGatewayDhcpReservationArgs.builder()
            .gatewayNetworkId(mainGatewayNetwork.id())
            .macAddress(mainPrivateNic.macAddress())
            .ipAddress("192.168.1.4")
            .build());

        //## VPC PAT RULE
        var mainPublicGatewayPatRule = new PublicGatewayPatRule("mainPublicGatewayPatRule", PublicGatewayPatRuleArgs.builder()
            .gatewayId(mainPublicGateway.id())
            .privateIp(mainPublicGatewayDhcpReservation.ipAddress())
            .privatePort(22)
            .publicPort(2222)
            .protocol("tcp")
            .build());

        final var byId = NetworkFunctions.getPublicGatewayDhcpReservation(GetPublicGatewayDhcpReservationArgs.builder()
            .reservationId(mainPublicGatewayDhcpReservation.id())
            .build());

    }
}
Copy
resources:
  main:
    type: scaleway:network:PrivateNetwork
  mainSecurityGroup:
    type: scaleway:instance:SecurityGroup
    name: main
    properties:
      inboundDefaultPolicy: drop
      outboundDefaultPolicy: accept
      inboundRules:
        - action: accept
          port: '22'
  mainServer:
    type: scaleway:instance:Server
    name: main
    properties:
      image: ubuntu_jammy
      type: DEV1-S
      zone: fr-par-1
      securityGroupId: ${mainSecurityGroup.id}
  mainPrivateNic:
    type: scaleway:instance:PrivateNic
    name: main
    properties:
      serverId: ${mainServer.id}
      privateNetworkId: ${main.id}
  mainPublicGatewayIp:
    type: scaleway:network:PublicGatewayIp
    name: main
  mainPublicGatewayDhcp:
    type: scaleway:network:PublicGatewayDhcp
    name: main
    properties:
      subnet: 192.168.1.0/24
  mainPublicGateway:
    type: scaleway:network:PublicGateway
    name: main
    properties:
      name: foobar
      type: VPC-GW-S
      ipId: ${mainPublicGatewayIp.id}
  mainGatewayNetwork:
    type: scaleway:network:GatewayNetwork
    name: main
    properties:
      gatewayId: ${mainPublicGateway.id}
      privateNetworkId: ${main.id}
      dhcpId: ${mainPublicGatewayDhcp.id}
      cleanupDhcp: true
      enableMasquerade: true
  mainPublicGatewayDhcpReservation:
    type: scaleway:network:PublicGatewayDhcpReservation
    name: main
    properties:
      gatewayNetworkId: ${mainGatewayNetwork.id}
      macAddress: ${mainPrivateNic.macAddress}
      ipAddress: 192.168.1.4
  ### VPC PAT RULE
  mainPublicGatewayPatRule:
    type: scaleway:network:PublicGatewayPatRule
    name: main
    properties:
      gatewayId: ${mainPublicGateway.id}
      privateIp: ${mainPublicGatewayDhcpReservation.ipAddress}
      privatePort: 22
      publicPort: 2222
      protocol: tcp
variables:
  byId:
    fn::invoke:
      function: scaleway:network:getPublicGatewayDhcpReservation
      arguments:
        reservationId: ${mainPublicGatewayDhcpReservation.id}
Copy

Using getPublicGatewayDhcpReservation

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 getPublicGatewayDhcpReservation(args: GetPublicGatewayDhcpReservationArgs, opts?: InvokeOptions): Promise<GetPublicGatewayDhcpReservationResult>
function getPublicGatewayDhcpReservationOutput(args: GetPublicGatewayDhcpReservationOutputArgs, opts?: InvokeOptions): Output<GetPublicGatewayDhcpReservationResult>
Copy
def get_public_gateway_dhcp_reservation(gateway_network_id: Optional[str] = None,
                                        mac_address: Optional[str] = None,
                                        reservation_id: Optional[str] = None,
                                        wait_for_dhcp: Optional[bool] = None,
                                        zone: Optional[str] = None,
                                        opts: Optional[InvokeOptions] = None) -> GetPublicGatewayDhcpReservationResult
def get_public_gateway_dhcp_reservation_output(gateway_network_id: Optional[pulumi.Input[str]] = None,
                                        mac_address: Optional[pulumi.Input[str]] = None,
                                        reservation_id: Optional[pulumi.Input[str]] = None,
                                        wait_for_dhcp: Optional[pulumi.Input[bool]] = None,
                                        zone: Optional[pulumi.Input[str]] = None,
                                        opts: Optional[InvokeOptions] = None) -> Output[GetPublicGatewayDhcpReservationResult]
Copy
func LookupPublicGatewayDhcpReservation(ctx *Context, args *LookupPublicGatewayDhcpReservationArgs, opts ...InvokeOption) (*LookupPublicGatewayDhcpReservationResult, error)
func LookupPublicGatewayDhcpReservationOutput(ctx *Context, args *LookupPublicGatewayDhcpReservationOutputArgs, opts ...InvokeOption) LookupPublicGatewayDhcpReservationResultOutput
Copy

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

public static class GetPublicGatewayDhcpReservation 
{
    public static Task<GetPublicGatewayDhcpReservationResult> InvokeAsync(GetPublicGatewayDhcpReservationArgs args, InvokeOptions? opts = null)
    public static Output<GetPublicGatewayDhcpReservationResult> Invoke(GetPublicGatewayDhcpReservationInvokeArgs args, InvokeOptions? opts = null)
}
Copy
public static CompletableFuture<GetPublicGatewayDhcpReservationResult> getPublicGatewayDhcpReservation(GetPublicGatewayDhcpReservationArgs args, InvokeOptions options)
public static Output<GetPublicGatewayDhcpReservationResult> getPublicGatewayDhcpReservation(GetPublicGatewayDhcpReservationArgs args, InvokeOptions options)
Copy
fn::invoke:
  function: scaleway:network/getPublicGatewayDhcpReservation:getPublicGatewayDhcpReservation
  arguments:
    # arguments dictionary
Copy

The following arguments are supported:

GatewayNetworkId string

The ID of the owning GatewayNetwork.

Only one of reservation_id or mac_address with gateway_network_id should be specified.

MacAddress string
The MAC address of the reservation to retrieve.
ReservationId string
The ID of the reservation (DHCP entry) to retrieve.
WaitForDhcp bool
Whether to wait for mac_address to exist in DHCP.
Zone string
zone). The zone in which the reservation exists.
GatewayNetworkId string

The ID of the owning GatewayNetwork.

Only one of reservation_id or mac_address with gateway_network_id should be specified.

MacAddress string
The MAC address of the reservation to retrieve.
ReservationId string
The ID of the reservation (DHCP entry) to retrieve.
WaitForDhcp bool
Whether to wait for mac_address to exist in DHCP.
Zone string
zone). The zone in which the reservation exists.
gatewayNetworkId String

The ID of the owning GatewayNetwork.

Only one of reservation_id or mac_address with gateway_network_id should be specified.

macAddress String
The MAC address of the reservation to retrieve.
reservationId String
The ID of the reservation (DHCP entry) to retrieve.
waitForDhcp Boolean
Whether to wait for mac_address to exist in DHCP.
zone String
zone). The zone in which the reservation exists.
gatewayNetworkId string

The ID of the owning GatewayNetwork.

Only one of reservation_id or mac_address with gateway_network_id should be specified.

macAddress string
The MAC address of the reservation to retrieve.
reservationId string
The ID of the reservation (DHCP entry) to retrieve.
waitForDhcp boolean
Whether to wait for mac_address to exist in DHCP.
zone string
zone). The zone in which the reservation exists.
gateway_network_id str

The ID of the owning GatewayNetwork.

Only one of reservation_id or mac_address with gateway_network_id should be specified.

mac_address str
The MAC address of the reservation to retrieve.
reservation_id str
The ID of the reservation (DHCP entry) to retrieve.
wait_for_dhcp bool
Whether to wait for mac_address to exist in DHCP.
zone str
zone). The zone in which the reservation exists.
gatewayNetworkId String

The ID of the owning GatewayNetwork.

Only one of reservation_id or mac_address with gateway_network_id should be specified.

macAddress String
The MAC address of the reservation to retrieve.
reservationId String
The ID of the reservation (DHCP entry) to retrieve.
waitForDhcp Boolean
Whether to wait for mac_address to exist in DHCP.
zone String
zone). The zone in which the reservation exists.

getPublicGatewayDhcpReservation Result

The following output properties are available:

CreatedAt string
Hostname string
Id string
The provider-assigned unique ID for this managed resource.
IpAddress string
Type string
UpdatedAt string
GatewayNetworkId string
MacAddress string
ReservationId string
WaitForDhcp bool
Zone string
CreatedAt string
Hostname string
Id string
The provider-assigned unique ID for this managed resource.
IpAddress string
Type string
UpdatedAt string
GatewayNetworkId string
MacAddress string
ReservationId string
WaitForDhcp bool
Zone string
createdAt String
hostname String
id String
The provider-assigned unique ID for this managed resource.
ipAddress String
type String
updatedAt String
gatewayNetworkId String
macAddress String
reservationId String
waitForDhcp Boolean
zone String
createdAt string
hostname string
id string
The provider-assigned unique ID for this managed resource.
ipAddress string
type string
updatedAt string
gatewayNetworkId string
macAddress string
reservationId string
waitForDhcp boolean
zone string
created_at str
hostname str
id str
The provider-assigned unique ID for this managed resource.
ip_address str
type str
updated_at str
gateway_network_id str
mac_address str
reservation_id str
wait_for_dhcp bool
zone str
createdAt String
hostname String
id String
The provider-assigned unique ID for this managed resource.
ipAddress String
type String
updatedAt String
gatewayNetworkId String
macAddress String
reservationId String
waitForDhcp Boolean
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 v1.26.0 published on Friday, Mar 28, 2025 by pulumiverse
pulumiverse/pulumi-scaleway