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

scaleway.network.GatewayNetwork

Explore with Pulumi AI

scaleway logo
Scaleway v1.25.0 published on Saturday, Mar 22, 2025 by pulumiverse
pulumiverse/pulumi-scaleway

    Creates and manages GatewayNetworks (connections between a Public Gateway and a Private Network).

    It allows the attachment of Private Networks to Public Gateways and DHCP configurations. For more information, see the API documentation.

    Example Usage

    Create a GatewayNetwork with IPAM configuration

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

const vpc01 = new scaleway.network.Vpc("vpc01", {name: "my vpc"});
const pn01 = new scaleway.network.PrivateNetwork("pn01", {
    name: "pn_test_network",
    ipv4Subnet: {
        subnet: "172.16.64.0/22",
    },
    vpcId: vpc01.id,
});
const pg01 = new scaleway.network.PublicGateway("pg01", {
    name: "foobar",
    type: "VPC-GW-S",
});
const main = new scaleway.network.GatewayNetwork("main", {
    gatewayId: pg01.id,
    privateNetworkId: pn01.id,
    enableMasquerade: true,
    ipamConfigs: [{
        pushDefaultRoute: true,
    }],
});

    import pulumi
import pulumiverse_scaleway as scaleway

vpc01 = scaleway.network.Vpc("vpc01", name="my vpc")
pn01 = scaleway.network.PrivateNetwork("pn01",
    name="pn_test_network",
    ipv4_subnet={
        "subnet": "172.16.64.0/22",
    },
    vpc_id=vpc01.id)
pg01 = scaleway.network.PublicGateway("pg01",
    name="foobar",
    type="VPC-GW-S")
main = scaleway.network.GatewayNetwork("main",
    gateway_id=pg01.id,
    private_network_id=pn01.id,
    enable_masquerade=True,
    ipam_configs=[{
        "push_default_route": True,
    }])

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		vpc01, err := network.NewVpc(ctx, "vpc01", &network.VpcArgs{
			Name: pulumi.String("my vpc"),
		})
		if err != nil {
			return err
		}
		pn01, err := network.NewPrivateNetwork(ctx, "pn01", &network.PrivateNetworkArgs{
			Name: pulumi.String("pn_test_network"),
			Ipv4Subnet: &network.PrivateNetworkIpv4SubnetArgs{
				Subnet: pulumi.String("172.16.64.0/22"),
			},
			VpcId: vpc01.ID(),
		})
		if err != nil {
			return err
		}
		pg01, err := network.NewPublicGateway(ctx, "pg01", &network.PublicGatewayArgs{
			Name: pulumi.String("foobar"),
			Type: pulumi.String("VPC-GW-S"),
		})
		if err != nil {
			return err
		}
		_, err = network.NewGatewayNetwork(ctx, "main", &network.GatewayNetworkArgs{
			GatewayId:        pg01.ID(),
			PrivateNetworkId: pn01.ID(),
			EnableMasquerade: pulumi.Bool(true),
			IpamConfigs: network.GatewayNetworkIpamConfigArray{
				&network.GatewayNetworkIpamConfigArgs{
					PushDefaultRoute: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var vpc01 = new Scaleway.Network.Vpc("vpc01", new()
    {
        Name = "my vpc",
    });

    var pn01 = new Scaleway.Network.PrivateNetwork("pn01", new()
    {
        Name = "pn_test_network",
        Ipv4Subnet = new Scaleway.Network.Inputs.PrivateNetworkIpv4SubnetArgs
        {
            Subnet = "172.16.64.0/22",
        },
        VpcId = vpc01.Id,
    });

    var pg01 = new Scaleway.Network.PublicGateway("pg01", new()
    {
        Name = "foobar",
        Type = "VPC-GW-S",
    });

    var main = new Scaleway.Network.GatewayNetwork("main", new()
    {
        GatewayId = pg01.Id,
        PrivateNetworkId = pn01.Id,
        EnableMasquerade = true,
        IpamConfigs = new[]
        {
            new Scaleway.Network.Inputs.GatewayNetworkIpamConfigArgs
            {
                PushDefaultRoute = true,
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.network.Vpc;
import com.pulumi.scaleway.network.VpcArgs;
import com.pulumi.scaleway.network.PrivateNetwork;
import com.pulumi.scaleway.network.PrivateNetworkArgs;
import com.pulumi.scaleway.network.inputs.PrivateNetworkIpv4SubnetArgs;
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.inputs.GatewayNetworkIpamConfigArgs;
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 vpc01 = new Vpc("vpc01", VpcArgs.builder()
            .name("my vpc")
            .build());

        var pn01 = new PrivateNetwork("pn01", PrivateNetworkArgs.builder()
            .name("pn_test_network")
            .ipv4Subnet(PrivateNetworkIpv4SubnetArgs.builder()
                .subnet("172.16.64.0/22")
                .build())
            .vpcId(vpc01.id())
            .build());

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

        var main = new GatewayNetwork("main", GatewayNetworkArgs.builder()
            .gatewayId(pg01.id())
            .privateNetworkId(pn01.id())
            .enableMasquerade(true)
            .ipamConfigs(GatewayNetworkIpamConfigArgs.builder()
                .pushDefaultRoute(true)
                .build())
            .build());

    }
}

    resources:
  vpc01:
    type: scaleway:network:Vpc
    properties:
      name: my vpc
  pn01:
    type: scaleway:network:PrivateNetwork
    properties:
      name: pn_test_network
      ipv4Subnet:
        subnet: 172.16.64.0/22
      vpcId: ${vpc01.id}
  pg01:
    type: scaleway:network:PublicGateway
    properties:
      name: foobar
      type: VPC-GW-S
  main:
    type: scaleway:network:GatewayNetwork
    properties:
      gatewayId: ${pg01.id}
      privateNetworkId: ${pn01.id}
      enableMasquerade: true
      ipamConfigs:
        - pushDefaultRoute: true

    Create a GatewayNetwork with a booked IPAM IP

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

const vpc01 = new scaleway.network.Vpc("vpc01", {name: "my vpc"});
const pn01 = new scaleway.network.PrivateNetwork("pn01", {
    name: "pn_test_network",
    ipv4Subnet: {
        subnet: "172.16.64.0/22",
    },
    vpcId: vpc01.id,
});
const ip01 = new scaleway.ipam.Ip("ip01", {
    address: "172.16.64.7",
    sources: [{
        privateNetworkId: pn01.id,
    }],
});
const pg01 = new scaleway.network.PublicGateway("pg01", {
    name: "foobar",
    type: "VPC-GW-S",
});
const main = new scaleway.network.GatewayNetwork("main", {
    gatewayId: pg01.id,
    privateNetworkId: pn01.id,
    enableMasquerade: true,
    ipamConfigs: [{
        pushDefaultRoute: true,
        ipamIpId: ip01.id,
    }],
});

    import pulumi
import pulumiverse_scaleway as scaleway

vpc01 = scaleway.network.Vpc("vpc01", name="my vpc")
pn01 = scaleway.network.PrivateNetwork("pn01",
    name="pn_test_network",
    ipv4_subnet={
        "subnet": "172.16.64.0/22",
    },
    vpc_id=vpc01.id)
ip01 = scaleway.ipam.Ip("ip01",
    address="172.16.64.7",
    sources=[{
        "private_network_id": pn01.id,
    }])
pg01 = scaleway.network.PublicGateway("pg01",
    name="foobar",
    type="VPC-GW-S")
main = scaleway.network.GatewayNetwork("main",
    gateway_id=pg01.id,
    private_network_id=pn01.id,
    enable_masquerade=True,
    ipam_configs=[{
        "push_default_route": True,
        "ipam_ip_id": ip01.id,
    }])

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		vpc01, err := network.NewVpc(ctx, "vpc01", &network.VpcArgs{
			Name: pulumi.String("my vpc"),
		})
		if err != nil {
			return err
		}
		pn01, err := network.NewPrivateNetwork(ctx, "pn01", &network.PrivateNetworkArgs{
			Name: pulumi.String("pn_test_network"),
			Ipv4Subnet: &network.PrivateNetworkIpv4SubnetArgs{
				Subnet: pulumi.String("172.16.64.0/22"),
			},
			VpcId: vpc01.ID(),
		})
		if err != nil {
			return err
		}
		ip01, err := ipam.NewIp(ctx, "ip01", &ipam.IpArgs{
			Address: pulumi.String("172.16.64.7"),
			Sources: ipam.IpSourceArray{
				&ipam.IpSourceArgs{
					PrivateNetworkId: pn01.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		pg01, err := network.NewPublicGateway(ctx, "pg01", &network.PublicGatewayArgs{
			Name: pulumi.String("foobar"),
			Type: pulumi.String("VPC-GW-S"),
		})
		if err != nil {
			return err
		}
		_, err = network.NewGatewayNetwork(ctx, "main", &network.GatewayNetworkArgs{
			GatewayId:        pg01.ID(),
			PrivateNetworkId: pn01.ID(),
			EnableMasquerade: pulumi.Bool(true),
			IpamConfigs: network.GatewayNetworkIpamConfigArray{
				&network.GatewayNetworkIpamConfigArgs{
					PushDefaultRoute: pulumi.Bool(true),
					IpamIpId:         ip01.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var vpc01 = new Scaleway.Network.Vpc("vpc01", new()
    {
        Name = "my vpc",
    });

    var pn01 = new Scaleway.Network.PrivateNetwork("pn01", new()
    {
        Name = "pn_test_network",
        Ipv4Subnet = new Scaleway.Network.Inputs.PrivateNetworkIpv4SubnetArgs
        {
            Subnet = "172.16.64.0/22",
        },
        VpcId = vpc01.Id,
    });

    var ip01 = new Scaleway.Ipam.Ip("ip01", new()
    {
        Address = "172.16.64.7",
        Sources = new[]
        {
            new Scaleway.Ipam.Inputs.IpSourceArgs
            {
                PrivateNetworkId = pn01.Id,
            },
        },
    });

    var pg01 = new Scaleway.Network.PublicGateway("pg01", new()
    {
        Name = "foobar",
        Type = "VPC-GW-S",
    });

    var main = new Scaleway.Network.GatewayNetwork("main", new()
    {
        GatewayId = pg01.Id,
        PrivateNetworkId = pn01.Id,
        EnableMasquerade = true,
        IpamConfigs = new[]
        {
            new Scaleway.Network.Inputs.GatewayNetworkIpamConfigArgs
            {
                PushDefaultRoute = true,
                IpamIpId = ip01.Id,
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.network.Vpc;
import com.pulumi.scaleway.network.VpcArgs;
import com.pulumi.scaleway.network.PrivateNetwork;
import com.pulumi.scaleway.network.PrivateNetworkArgs;
import com.pulumi.scaleway.network.inputs.PrivateNetworkIpv4SubnetArgs;
import com.pulumi.scaleway.ipam.Ip;
import com.pulumi.scaleway.ipam.IpArgs;
import com.pulumi.scaleway.ipam.inputs.IpSourceArgs;
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.inputs.GatewayNetworkIpamConfigArgs;
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 vpc01 = new Vpc("vpc01", VpcArgs.builder()
            .name("my vpc")
            .build());

        var pn01 = new PrivateNetwork("pn01", PrivateNetworkArgs.builder()
            .name("pn_test_network")
            .ipv4Subnet(PrivateNetworkIpv4SubnetArgs.builder()
                .subnet("172.16.64.0/22")
                .build())
            .vpcId(vpc01.id())
            .build());

        var ip01 = new Ip("ip01", IpArgs.builder()
            .address("172.16.64.7")
            .sources(IpSourceArgs.builder()
                .privateNetworkId(pn01.id())
                .build())
            .build());

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

        var main = new GatewayNetwork("main", GatewayNetworkArgs.builder()
            .gatewayId(pg01.id())
            .privateNetworkId(pn01.id())
            .enableMasquerade(true)
            .ipamConfigs(GatewayNetworkIpamConfigArgs.builder()
                .pushDefaultRoute(true)
                .ipamIpId(ip01.id())
                .build())
            .build());

    }
}

    resources:
  vpc01:
    type: scaleway:network:Vpc
    properties:
      name: my vpc
  pn01:
    type: scaleway:network:PrivateNetwork
    properties:
      name: pn_test_network
      ipv4Subnet:
        subnet: 172.16.64.0/22
      vpcId: ${vpc01.id}
  ip01:
    type: scaleway:ipam:Ip
    properties:
      address: 172.16.64.7
      sources:
        - privateNetworkId: ${pn01.id}
  pg01:
    type: scaleway:network:PublicGateway
    properties:
      name: foobar
      type: VPC-GW-S
  main:
    type: scaleway:network:GatewayNetwork
    properties:
      gatewayId: ${pg01.id}
      privateNetworkId: ${pn01.id}
      enableMasquerade: true
      ipamConfigs:
        - pushDefaultRoute: true
          ipamIpId: ${ip01.id}

    Create a GatewayNetwork with DHCP

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

const pn01 = new scaleway.network.PrivateNetwork("pn01", {name: "pn_test_network"});
const gw01 = new scaleway.network.PublicGatewayIp("gw01", {});
const dhcp01 = new scaleway.network.PublicGatewayDhcp("dhcp01", {
    subnet: "192.168.1.0/24",
    pushDefaultRoute: true,
});
const pg01 = new scaleway.network.PublicGateway("pg01", {
    name: "foobar",
    type: "VPC-GW-S",
    ipId: gw01.id,
});
const main = new scaleway.network.GatewayNetwork("main", {
    gatewayId: pg01.id,
    privateNetworkId: pn01.id,
    dhcpId: dhcp01.id,
    cleanupDhcp: true,
    enableMasquerade: true,
});

    import pulumi
import pulumiverse_scaleway as scaleway

pn01 = scaleway.network.PrivateNetwork("pn01", name="pn_test_network")
gw01 = scaleway.network.PublicGatewayIp("gw01")
dhcp01 = scaleway.network.PublicGatewayDhcp("dhcp01",
    subnet="192.168.1.0/24",
    push_default_route=True)
pg01 = scaleway.network.PublicGateway("pg01",
    name="foobar",
    type="VPC-GW-S",
    ip_id=gw01.id)
main = scaleway.network.GatewayNetwork("main",
    gateway_id=pg01.id,
    private_network_id=pn01.id,
    dhcp_id=dhcp01.id,
    cleanup_dhcp=True,
    enable_masquerade=True)

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		pn01, err := network.NewPrivateNetwork(ctx, "pn01", &network.PrivateNetworkArgs{
			Name: pulumi.String("pn_test_network"),
		})
		if err != nil {
			return err
		}
		gw01, err := network.NewPublicGatewayIp(ctx, "gw01", nil)
		if err != nil {
			return err
		}
		dhcp01, err := network.NewPublicGatewayDhcp(ctx, "dhcp01", &network.PublicGatewayDhcpArgs{
			Subnet:           pulumi.String("192.168.1.0/24"),
			PushDefaultRoute: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		pg01, err := network.NewPublicGateway(ctx, "pg01", &network.PublicGatewayArgs{
			Name: pulumi.String("foobar"),
			Type: pulumi.String("VPC-GW-S"),
			IpId: gw01.ID(),
		})
		if err != nil {
			return err
		}
		_, err = network.NewGatewayNetwork(ctx, "main", &network.GatewayNetworkArgs{
			GatewayId:        pg01.ID(),
			PrivateNetworkId: pn01.ID(),
			DhcpId:           dhcp01.ID(),
			CleanupDhcp:      pulumi.Bool(true),
			EnableMasquerade: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var pn01 = new Scaleway.Network.PrivateNetwork("pn01", new()
    {
        Name = "pn_test_network",
    });

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

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

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

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

});

    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.network.PrivateNetworkArgs;
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 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 pn01 = new PrivateNetwork("pn01", PrivateNetworkArgs.builder()
            .name("pn_test_network")
            .build());

        var gw01 = new PublicGatewayIp("gw01");

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

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

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

    }
}

    resources:
  pn01:
    type: scaleway:network:PrivateNetwork
    properties:
      name: pn_test_network
  gw01:
    type: scaleway:network:PublicGatewayIp
  dhcp01:
    type: scaleway:network:PublicGatewayDhcp
    properties:
      subnet: 192.168.1.0/24
      pushDefaultRoute: true
  pg01:
    type: scaleway:network:PublicGateway
    properties:
      name: foobar
      type: VPC-GW-S
      ipId: ${gw01.id}
  main:
    type: scaleway:network:GatewayNetwork
    properties:
      gatewayId: ${pg01.id}
      privateNetworkId: ${pn01.id}
      dhcpId: ${dhcp01.id}
      cleanupDhcp: true
      enableMasquerade: true

    Create a GatewayNetwork with a static IP address

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

const pn01 = new scaleway.network.PrivateNetwork("pn01", {name: "pn_test_network"});
const pg01 = new scaleway.network.PublicGateway("pg01", {
    name: "foobar",
    type: "VPC-GW-S",
});
const main = new scaleway.network.GatewayNetwork("main", {
    gatewayId: pg01.id,
    privateNetworkId: pn01.id,
    enableDhcp: false,
    enableMasquerade: true,
    staticAddress: "192.168.1.42/24",
});

    import pulumi
import pulumiverse_scaleway as scaleway

pn01 = scaleway.network.PrivateNetwork("pn01", name="pn_test_network")
pg01 = scaleway.network.PublicGateway("pg01",
    name="foobar",
    type="VPC-GW-S")
main = scaleway.network.GatewayNetwork("main",
    gateway_id=pg01.id,
    private_network_id=pn01.id,
    enable_dhcp=False,
    enable_masquerade=True,
    static_address="192.168.1.42/24")

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		pn01, err := network.NewPrivateNetwork(ctx, "pn01", &network.PrivateNetworkArgs{
			Name: pulumi.String("pn_test_network"),
		})
		if err != nil {
			return err
		}
		pg01, err := network.NewPublicGateway(ctx, "pg01", &network.PublicGatewayArgs{
			Name: pulumi.String("foobar"),
			Type: pulumi.String("VPC-GW-S"),
		})
		if err != nil {
			return err
		}
		_, err = network.NewGatewayNetwork(ctx, "main", &network.GatewayNetworkArgs{
			GatewayId:        pg01.ID(),
			PrivateNetworkId: pn01.ID(),
			EnableDhcp:       pulumi.Bool(false),
			EnableMasquerade: pulumi.Bool(true),
			StaticAddress:    pulumi.String("192.168.1.42/24"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var pn01 = new Scaleway.Network.PrivateNetwork("pn01", new()
    {
        Name = "pn_test_network",
    });

    var pg01 = new Scaleway.Network.PublicGateway("pg01", new()
    {
        Name = "foobar",
        Type = "VPC-GW-S",
    });

    var main = new Scaleway.Network.GatewayNetwork("main", new()
    {
        GatewayId = pg01.Id,
        PrivateNetworkId = pn01.Id,
        EnableDhcp = false,
        EnableMasquerade = true,
        StaticAddress = "192.168.1.42/24",
    });

});

    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.network.PrivateNetworkArgs;
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 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 pn01 = new PrivateNetwork("pn01", PrivateNetworkArgs.builder()
            .name("pn_test_network")
            .build());

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

        var main = new GatewayNetwork("main", GatewayNetworkArgs.builder()
            .gatewayId(pg01.id())
            .privateNetworkId(pn01.id())
            .enableDhcp(false)
            .enableMasquerade(true)
            .staticAddress("192.168.1.42/24")
            .build());

    }
}

    resources:
  pn01:
    type: scaleway:network:PrivateNetwork
    properties:
      name: pn_test_network
  pg01:
    type: scaleway:network:PublicGateway
    properties:
      name: foobar
      type: VPC-GW-S
  main:
    type: scaleway:network:GatewayNetwork
    properties:
      gatewayId: ${pg01.id}
      privateNetworkId: ${pn01.id}
      enableDhcp: false
      enableMasquerade: true
      staticAddress: 192.168.1.42/24

    Create GatewayNetwork Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new GatewayNetwork(name: string, args: GatewayNetworkArgs, opts?: CustomResourceOptions);
    @overload
def GatewayNetwork(resource_name: str,
                   args: GatewayNetworkArgs,
                   opts: Optional[ResourceOptions] = None)

@overload
def GatewayNetwork(resource_name: str,
                   opts: Optional[ResourceOptions] = None,
                   gateway_id: Optional[str] = None,
                   private_network_id: Optional[str] = None,
                   cleanup_dhcp: Optional[bool] = None,
                   dhcp_id: Optional[str] = None,
                   enable_dhcp: Optional[bool] = None,
                   enable_masquerade: Optional[bool] = None,
                   ipam_configs: Optional[Sequence[GatewayNetworkIpamConfigArgs]] = None,
                   static_address: Optional[str] = None,
                   zone: Optional[str] = None)
    func NewGatewayNetwork(ctx *Context, name string, args GatewayNetworkArgs, opts ...ResourceOption) (*GatewayNetwork, error)
    public GatewayNetwork(string name, GatewayNetworkArgs args, CustomResourceOptions? opts = null)
    public GatewayNetwork(String name, GatewayNetworkArgs args)
public GatewayNetwork(String name, GatewayNetworkArgs args, CustomResourceOptions options)

    type: scaleway:network:GatewayNetwork
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args GatewayNetworkArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args GatewayNetworkArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args GatewayNetworkArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args GatewayNetworkArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args GatewayNetworkArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var gatewayNetworkResource = new Scaleway.Network.GatewayNetwork("gatewayNetworkResource", new()
{
    GatewayId = "string",
    PrivateNetworkId = "string",
    CleanupDhcp = false,
    DhcpId = "string",
    EnableDhcp = false,
    EnableMasquerade = false,
    IpamConfigs = new[]
    {
        new Scaleway.Network.Inputs.GatewayNetworkIpamConfigArgs
        {
            IpamIpId = "string",
            PushDefaultRoute = false,
        },
    },
    StaticAddress = "string",
    Zone = "string",
});

    example, err := network.NewGatewayNetwork(ctx, "gatewayNetworkResource", &network.GatewayNetworkArgs{
	GatewayId:        pulumi.String("string"),
	PrivateNetworkId: pulumi.String("string"),
	CleanupDhcp:      pulumi.Bool(false),
	DhcpId:           pulumi.String("string"),
	EnableDhcp:       pulumi.Bool(false),
	EnableMasquerade: pulumi.Bool(false),
	IpamConfigs: network.GatewayNetworkIpamConfigArray{
		&network.GatewayNetworkIpamConfigArgs{
			IpamIpId:         pulumi.String("string"),
			PushDefaultRoute: pulumi.Bool(false),
		},
	},
	StaticAddress: pulumi.String("string"),
	Zone:          pulumi.String("string"),
})

    var gatewayNetworkResource = new GatewayNetwork("gatewayNetworkResource", GatewayNetworkArgs.builder()
    .gatewayId("string")
    .privateNetworkId("string")
    .cleanupDhcp(false)
    .dhcpId("string")
    .enableDhcp(false)
    .enableMasquerade(false)
    .ipamConfigs(GatewayNetworkIpamConfigArgs.builder()
        .ipamIpId("string")
        .pushDefaultRoute(false)
        .build())
    .staticAddress("string")
    .zone("string")
    .build());

    gateway_network_resource = scaleway.network.GatewayNetwork("gatewayNetworkResource",
    gateway_id="string",
    private_network_id="string",
    cleanup_dhcp=False,
    dhcp_id="string",
    enable_dhcp=False,
    enable_masquerade=False,
    ipam_configs=[{
        "ipam_ip_id": "string",
        "push_default_route": False,
    }],
    static_address="string",
    zone="string")

    const gatewayNetworkResource = new scaleway.network.GatewayNetwork("gatewayNetworkResource", {
    gatewayId: "string",
    privateNetworkId: "string",
    cleanupDhcp: false,
    dhcpId: "string",
    enableDhcp: false,
    enableMasquerade: false,
    ipamConfigs: [{
        ipamIpId: "string",
        pushDefaultRoute: false,
    }],
    staticAddress: "string",
    zone: "string",
});

    type: scaleway:network:GatewayNetwork
properties:
    cleanupDhcp: false
    dhcpId: string
    enableDhcp: false
    enableMasquerade: false
    gatewayId: string
    ipamConfigs:
        - ipamIpId: string
          pushDefaultRoute: false
    privateNetworkId: string
    staticAddress: string
    zone: string

    GatewayNetwork Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The GatewayNetwork resource accepts the following input properties:

    GatewayId string
    The ID of the Public Gateway.
    PrivateNetworkId string
    The ID of the Private Network.
    CleanupDhcp bool
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    DhcpId string
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    EnableDhcp bool
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    EnableMasquerade bool
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    IpamConfigs List<Pulumiverse.Scaleway.Network.Inputs.GatewayNetworkIpamConfig>
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    StaticAddress string
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    Zone string
    zone) The zone in which the gateway network should be created.
    GatewayId string
    The ID of the Public Gateway.
    PrivateNetworkId string
    The ID of the Private Network.
    CleanupDhcp bool
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    DhcpId string
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    EnableDhcp bool
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    EnableMasquerade bool
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    IpamConfigs []GatewayNetworkIpamConfigArgs
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    StaticAddress string
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    Zone string
    zone) The zone in which the gateway network should be created.
    gatewayId String
    The ID of the Public Gateway.
    privateNetworkId String
    The ID of the Private Network.
    cleanupDhcp Boolean
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    dhcpId String
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    enableDhcp Boolean
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    enableMasquerade Boolean
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    ipamConfigs List<GatewayNetworkIpamConfig>
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    staticAddress String
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    zone String
    zone) The zone in which the gateway network should be created.
    gatewayId string
    The ID of the Public Gateway.
    privateNetworkId string
    The ID of the Private Network.
    cleanupDhcp boolean
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    dhcpId string
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    enableDhcp boolean
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    enableMasquerade boolean
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    ipamConfigs GatewayNetworkIpamConfig[]
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    staticAddress string
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    zone string
    zone) The zone in which the gateway network should be created.
    gateway_id str
    The ID of the Public Gateway.
    private_network_id str
    The ID of the Private Network.
    cleanup_dhcp bool
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    dhcp_id str
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    enable_dhcp bool
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    enable_masquerade bool
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    ipam_configs Sequence[GatewayNetworkIpamConfigArgs]
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    static_address str
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    zone str
    zone) The zone in which the gateway network should be created.
    gatewayId String
    The ID of the Public Gateway.
    privateNetworkId String
    The ID of the Private Network.
    cleanupDhcp Boolean
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    dhcpId String
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    enableDhcp Boolean
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    enableMasquerade Boolean
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    ipamConfigs List<Property Map>
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    staticAddress String
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    zone String
    zone) The zone in which the gateway network should be created.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the GatewayNetwork resource produces the following output properties:

    CreatedAt string
    The date and time of the creation of the GatewayNetwork.
    Id string
    The provider-assigned unique ID for this managed resource.
    MacAddress string
    The MAC address of the GatewayNetwork.
    Status string
    The status of the Public Gateway's connection to the Private Network.
    UpdatedAt string
    The date and time of the last update of the GatewayNetwork.
    CreatedAt string
    The date and time of the creation of the GatewayNetwork.
    Id string
    The provider-assigned unique ID for this managed resource.
    MacAddress string
    The MAC address of the GatewayNetwork.
    Status string
    The status of the Public Gateway's connection to the Private Network.
    UpdatedAt string
    The date and time of the last update of the GatewayNetwork.
    createdAt String
    The date and time of the creation of the GatewayNetwork.
    id String
    The provider-assigned unique ID for this managed resource.
    macAddress String
    The MAC address of the GatewayNetwork.
    status String
    The status of the Public Gateway's connection to the Private Network.
    updatedAt String
    The date and time of the last update of the GatewayNetwork.
    createdAt string
    The date and time of the creation of the GatewayNetwork.
    id string
    The provider-assigned unique ID for this managed resource.
    macAddress string
    The MAC address of the GatewayNetwork.
    status string
    The status of the Public Gateway's connection to the Private Network.
    updatedAt string
    The date and time of the last update of the GatewayNetwork.
    created_at str
    The date and time of the creation of the GatewayNetwork.
    id str
    The provider-assigned unique ID for this managed resource.
    mac_address str
    The MAC address of the GatewayNetwork.
    status str
    The status of the Public Gateway's connection to the Private Network.
    updated_at str
    The date and time of the last update of the GatewayNetwork.
    createdAt String
    The date and time of the creation of the GatewayNetwork.
    id String
    The provider-assigned unique ID for this managed resource.
    macAddress String
    The MAC address of the GatewayNetwork.
    status String
    The status of the Public Gateway's connection to the Private Network.
    updatedAt String
    The date and time of the last update of the GatewayNetwork.

    Look up Existing GatewayNetwork Resource

    Get an existing GatewayNetwork resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: GatewayNetworkState, opts?: CustomResourceOptions): GatewayNetwork
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        cleanup_dhcp: Optional[bool] = None,
        created_at: Optional[str] = None,
        dhcp_id: Optional[str] = None,
        enable_dhcp: Optional[bool] = None,
        enable_masquerade: Optional[bool] = None,
        gateway_id: Optional[str] = None,
        ipam_configs: Optional[Sequence[GatewayNetworkIpamConfigArgs]] = None,
        mac_address: Optional[str] = None,
        private_network_id: Optional[str] = None,
        static_address: Optional[str] = None,
        status: Optional[str] = None,
        updated_at: Optional[str] = None,
        zone: Optional[str] = None) -> GatewayNetwork
    func GetGatewayNetwork(ctx *Context, name string, id IDInput, state *GatewayNetworkState, opts ...ResourceOption) (*GatewayNetwork, error)
    public static GatewayNetwork Get(string name, Input<string> id, GatewayNetworkState? state, CustomResourceOptions? opts = null)
    public static GatewayNetwork get(String name, Output<String> id, GatewayNetworkState state, CustomResourceOptions options)
    resources:  _:    type: scaleway:network:GatewayNetwork    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    CleanupDhcp bool
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    CreatedAt string
    The date and time of the creation of the GatewayNetwork.
    DhcpId string
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    EnableDhcp bool
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    EnableMasquerade bool
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    GatewayId string
    The ID of the Public Gateway.
    IpamConfigs List<Pulumiverse.Scaleway.Network.Inputs.GatewayNetworkIpamConfig>
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    MacAddress string
    The MAC address of the GatewayNetwork.
    PrivateNetworkId string
    The ID of the Private Network.
    StaticAddress string
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    Status string
    The status of the Public Gateway's connection to the Private Network.
    UpdatedAt string
    The date and time of the last update of the GatewayNetwork.
    Zone string
    zone) The zone in which the gateway network should be created.
    CleanupDhcp bool
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    CreatedAt string
    The date and time of the creation of the GatewayNetwork.
    DhcpId string
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    EnableDhcp bool
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    EnableMasquerade bool
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    GatewayId string
    The ID of the Public Gateway.
    IpamConfigs []GatewayNetworkIpamConfigArgs
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    MacAddress string
    The MAC address of the GatewayNetwork.
    PrivateNetworkId string
    The ID of the Private Network.
    StaticAddress string
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    Status string
    The status of the Public Gateway's connection to the Private Network.
    UpdatedAt string
    The date and time of the last update of the GatewayNetwork.
    Zone string
    zone) The zone in which the gateway network should be created.
    cleanupDhcp Boolean
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    createdAt String
    The date and time of the creation of the GatewayNetwork.
    dhcpId String
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    enableDhcp Boolean
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    enableMasquerade Boolean
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    gatewayId String
    The ID of the Public Gateway.
    ipamConfigs List<GatewayNetworkIpamConfig>
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    macAddress String
    The MAC address of the GatewayNetwork.
    privateNetworkId String
    The ID of the Private Network.
    staticAddress String
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    status String
    The status of the Public Gateway's connection to the Private Network.
    updatedAt String
    The date and time of the last update of the GatewayNetwork.
    zone String
    zone) The zone in which the gateway network should be created.
    cleanupDhcp boolean
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    createdAt string
    The date and time of the creation of the GatewayNetwork.
    dhcpId string
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    enableDhcp boolean
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    enableMasquerade boolean
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    gatewayId string
    The ID of the Public Gateway.
    ipamConfigs GatewayNetworkIpamConfig[]
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    macAddress string
    The MAC address of the GatewayNetwork.
    privateNetworkId string
    The ID of the Private Network.
    staticAddress string
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    status string
    The status of the Public Gateway's connection to the Private Network.
    updatedAt string
    The date and time of the last update of the GatewayNetwork.
    zone string
    zone) The zone in which the gateway network should be created.
    cleanup_dhcp bool
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    created_at str
    The date and time of the creation of the GatewayNetwork.
    dhcp_id str
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    enable_dhcp bool
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    enable_masquerade bool
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    gateway_id str
    The ID of the Public Gateway.
    ipam_configs Sequence[GatewayNetworkIpamConfigArgs]
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    mac_address str
    The MAC address of the GatewayNetwork.
    private_network_id str
    The ID of the Private Network.
    static_address str
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    status str
    The status of the Public Gateway's connection to the Private Network.
    updated_at str
    The date and time of the last update of the GatewayNetwork.
    zone str
    zone) The zone in which the gateway network should be created.
    cleanupDhcp Boolean
    Whether to remove DHCP configuration on this GatewayNetwork upon destroy. Requires DHCP ID.
    createdAt String
    The date and time of the creation of the GatewayNetwork.
    dhcpId String
    The ID of the Public Gateway DHCP configuration. Only one of dhcp_id, static_address and ipam_config should be specified.
    enableDhcp Boolean
    Whether a DHCP configuration should be enabled on this GatewayNetwork. Requires a DHCP ID.
    enableMasquerade Boolean
    Whether masquerade (dynamic NAT) should be enabled on this GatewayNetwork
    gatewayId String
    The ID of the Public Gateway.
    ipamConfigs List<Property Map>
    Auto-configure the GatewayNetwork using Scaleway's IPAM (IP address management service). Only one of dhcp_id, static_address and ipam_config should be specified.
    macAddress String
    The MAC address of the GatewayNetwork.
    privateNetworkId String
    The ID of the Private Network.
    staticAddress String
    Enable DHCP configration on this GatewayNetwork. Only one of dhcp_id, static_address and ipam_config should be specified.
    status String
    The status of the Public Gateway's connection to the Private Network.
    updatedAt String
    The date and time of the last update of the GatewayNetwork.
    zone String
    zone) The zone in which the gateway network should be created.

    Supporting Types

    GatewayNetworkIpamConfig, GatewayNetworkIpamConfigArgs

    IpamIpId string
    Use this IPAM-booked IP ID as the Gateway's IP in this Private Network.
    PushDefaultRoute bool
    Defines whether to enable the default route on the GatewayNetwork.
    IpamIpId string
    Use this IPAM-booked IP ID as the Gateway's IP in this Private Network.
    PushDefaultRoute bool
    Defines whether to enable the default route on the GatewayNetwork.
    ipamIpId String
    Use this IPAM-booked IP ID as the Gateway's IP in this Private Network.
    pushDefaultRoute Boolean
    Defines whether to enable the default route on the GatewayNetwork.
    ipamIpId string
    Use this IPAM-booked IP ID as the Gateway's IP in this Private Network.
    pushDefaultRoute boolean
    Defines whether to enable the default route on the GatewayNetwork.
    ipam_ip_id str
    Use this IPAM-booked IP ID as the Gateway's IP in this Private Network.
    push_default_route bool
    Defines whether to enable the default route on the GatewayNetwork.
    ipamIpId String
    Use this IPAM-booked IP ID as the Gateway's IP in this Private Network.
    pushDefaultRoute Boolean
    Defines whether to enable the default route on the GatewayNetwork.

    Import

    GatewayNetwork can be imported using {zone}/{id}, e.g.

    bash

    $ pulumi import scaleway:network/gatewayNetwork:GatewayNetwork main fr-par-1/11111111-1111-1111-1111-111111111111

    To learn more about importing existing cloud resources, see Importing resources.

    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