scaleway.DatabaseInstance

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

const main = new scaleway.DatabaseInstance("main", {
    disableBackup: true,
    engine: "PostgreSQL-11",
    isHaCluster: true,
    nodeType: "DB-DEV-S",
    password: "thiZ_is_v&ry_s3cret",
    userName: "my_initial_user",
});

import pulumi
import lbrlabs_pulumi_scaleway as scaleway

main = scaleway.DatabaseInstance("main",
    disable_backup=True,
    engine="PostgreSQL-11",
    is_ha_cluster=True,
    node_type="DB-DEV-S",
    password="thiZ_is_v&ry_s3cret",
    user_name="my_initial_user")

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

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.DatabaseInstance("main", new()
    {
        DisableBackup = true,
        Engine = "PostgreSQL-11",
        IsHaCluster = true,
        NodeType = "DB-DEV-S",
        Password = "thiZ_is_v&ry_s3cret",
        UserName = "my_initial_user",
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := scaleway.NewDatabaseInstance(ctx, "main", &scaleway.DatabaseInstanceArgs{
			DisableBackup: pulumi.Bool(true),
			Engine:        pulumi.String("PostgreSQL-11"),
			IsHaCluster:   pulumi.Bool(true),
			NodeType:      pulumi.String("DB-DEV-S"),
			Password:      pulumi.String("thiZ_is_v&ry_s3cret"),
			UserName:      pulumi.String("my_initial_user"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.DatabaseInstance;
import com.pulumi.scaleway.DatabaseInstanceArgs;
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 DatabaseInstance("main", DatabaseInstanceArgs.builder()        
            .disableBackup(true)
            .engine("PostgreSQL-11")
            .isHaCluster(true)
            .nodeType("DB-DEV-S")
            .password("thiZ_is_v&ry_s3cret")
            .userName("my_initial_user")
            .build());

    }
}

resources:
  main:
    type: scaleway:DatabaseInstance
    properties:
      disableBackup: true
      engine: PostgreSQL-11
      isHaCluster: true
      nodeType: DB-DEV-S
      password: thiZ_is_v&ry_s3cret
      userName: my_initial_user

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

const pn = new scaleway.VpcPrivateNetwork("pn", {});
const main = new scaleway.DatabaseInstance("main", {
    nodeType: "DB-DEV-S",
    engine: "PostgreSQL-11",
    isHaCluster: true,
    disableBackup: true,
    userName: "my_initial_user",
    password: "thiZ_is_v&ry_s3cret",
    privateNetwork: {
        pnId: pn.id,
    },
});

import pulumi
import lbrlabs_pulumi_scaleway as scaleway

pn = scaleway.VpcPrivateNetwork("pn")
main = scaleway.DatabaseInstance("main",
    node_type="DB-DEV-S",
    engine="PostgreSQL-11",
    is_ha_cluster=True,
    disable_backup=True,
    user_name="my_initial_user",
    password="thiZ_is_v&ry_s3cret",
    private_network=scaleway.DatabaseInstancePrivateNetworkArgs(
        pn_id=pn.id,
    ))

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

return await Deployment.RunAsync(() => 
{
    var pn = new Scaleway.VpcPrivateNetwork("pn");

    var main = new Scaleway.DatabaseInstance("main", new()
    {
        NodeType = "DB-DEV-S",
        Engine = "PostgreSQL-11",
        IsHaCluster = true,
        DisableBackup = true,
        UserName = "my_initial_user",
        Password = "thiZ_is_v&ry_s3cret",
        PrivateNetwork = new Scaleway.Inputs.DatabaseInstancePrivateNetworkArgs
        {
            PnId = pn.Id,
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		pn, err := scaleway.NewVpcPrivateNetwork(ctx, "pn", nil)
		if err != nil {
			return err
		}
		_, err = scaleway.NewDatabaseInstance(ctx, "main", &scaleway.DatabaseInstanceArgs{
			NodeType:      pulumi.String("DB-DEV-S"),
			Engine:        pulumi.String("PostgreSQL-11"),
			IsHaCluster:   pulumi.Bool(true),
			DisableBackup: pulumi.Bool(true),
			UserName:      pulumi.String("my_initial_user"),
			Password:      pulumi.String("thiZ_is_v&ry_s3cret"),
			PrivateNetwork: &scaleway.DatabaseInstancePrivateNetworkArgs{
				PnId: pn.ID(),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.VpcPrivateNetwork;
import com.pulumi.scaleway.DatabaseInstance;
import com.pulumi.scaleway.DatabaseInstanceArgs;
import com.pulumi.scaleway.inputs.DatabaseInstancePrivateNetworkArgs;
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 pn = new VpcPrivateNetwork("pn");

        var main = new DatabaseInstance("main", DatabaseInstanceArgs.builder()        
            .nodeType("DB-DEV-S")
            .engine("PostgreSQL-11")
            .isHaCluster(true)
            .disableBackup(true)
            .userName("my_initial_user")
            .password("thiZ_is_v&ry_s3cret")
            .privateNetwork(DatabaseInstancePrivateNetworkArgs.builder()
                .pnId(pn.id())
                .build())
            .build());

    }
}

resources:
  pn:
    type: scaleway:VpcPrivateNetwork
  main:
    type: scaleway:DatabaseInstance
    properties:
      nodeType: DB-DEV-S
      engine: PostgreSQL-11
      isHaCluster: true
      disableBackup: true
      userName: my_initial_user
      password: thiZ_is_v&ry_s3cret
      privateNetwork:
        pnId: ${pn.id}

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

const main = new scaleway.DatabaseInstance("main", {
    disableBackup: true,
    engine: "MySQL-8",
    initSettings: {
        lower_case_table_names: "1",
    },
    nodeType: "db-dev-s",
    password: "thiZ_is_v&ry_s3cret",
    settings: {
        max_connections: "350",
    },
    userName: "my_initial_user",
});

import pulumi
import lbrlabs_pulumi_scaleway as scaleway

main = scaleway.DatabaseInstance("main",
    disable_backup=True,
    engine="MySQL-8",
    init_settings={
        "lower_case_table_names": "1",
    },
    node_type="db-dev-s",
    password="thiZ_is_v&ry_s3cret",
    settings={
        "max_connections": "350",
    },
    user_name="my_initial_user")

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

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.DatabaseInstance("main", new()
    {
        DisableBackup = true,
        Engine = "MySQL-8",
        InitSettings = 
        {
            { "lower_case_table_names", "1" },
        },
        NodeType = "db-dev-s",
        Password = "thiZ_is_v&ry_s3cret",
        Settings = 
        {
            { "max_connections", "350" },
        },
        UserName = "my_initial_user",
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := scaleway.NewDatabaseInstance(ctx, "main", &scaleway.DatabaseInstanceArgs{
			DisableBackup: pulumi.Bool(true),
			Engine:        pulumi.String("MySQL-8"),
			InitSettings: pulumi.StringMap{
				"lower_case_table_names": pulumi.String("1"),
			},
			NodeType: pulumi.String("db-dev-s"),
			Password: pulumi.String("thiZ_is_v&ry_s3cret"),
			Settings: pulumi.StringMap{
				"max_connections": pulumi.String("350"),
			},
			UserName: pulumi.String("my_initial_user"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.DatabaseInstance;
import com.pulumi.scaleway.DatabaseInstanceArgs;
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 DatabaseInstance("main", DatabaseInstanceArgs.builder()        
            .disableBackup(true)
            .engine("MySQL-8")
            .initSettings(Map.of("lower_case_table_names", 1))
            .nodeType("db-dev-s")
            .password("thiZ_is_v&ry_s3cret")
            .settings(Map.of("max_connections", "350"))
            .userName("my_initial_user")
            .build());

    }
}

resources:
  main:
    type: scaleway:DatabaseInstance
    properties:
      disableBackup: true
      engine: MySQL-8
      initSettings:
        lower_case_table_names: 1
      nodeType: db-dev-s
      password: thiZ_is_v&ry_s3cret
      settings:
        max_connections: '350'
      userName: my_initial_user

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

const main = new scaleway.DatabaseInstance("main", {
    backupScheduleFrequency: 24,
    backupScheduleRetention: 7,
    disableBackup: false,
    engine: "PostgreSQL-11",
    isHaCluster: true,
    nodeType: "DB-DEV-S",
    password: "thiZ_is_v&ry_s3cret",
    userName: "my_initial_user",
});

import pulumi
import lbrlabs_pulumi_scaleway as scaleway

main = scaleway.DatabaseInstance("main",
    backup_schedule_frequency=24,
    backup_schedule_retention=7,
    disable_backup=False,
    engine="PostgreSQL-11",
    is_ha_cluster=True,
    node_type="DB-DEV-S",
    password="thiZ_is_v&ry_s3cret",
    user_name="my_initial_user")

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

return await Deployment.RunAsync(() => 
{
    var main = new Scaleway.DatabaseInstance("main", new()
    {
        BackupScheduleFrequency = 24,
        BackupScheduleRetention = 7,
        DisableBackup = false,
        Engine = "PostgreSQL-11",
        IsHaCluster = true,
        NodeType = "DB-DEV-S",
        Password = "thiZ_is_v&ry_s3cret",
        UserName = "my_initial_user",
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := scaleway.NewDatabaseInstance(ctx, "main", &scaleway.DatabaseInstanceArgs{
			BackupScheduleFrequency: pulumi.Int(24),
			BackupScheduleRetention: pulumi.Int(7),
			DisableBackup:           pulumi.Bool(false),
			Engine:                  pulumi.String("PostgreSQL-11"),
			IsHaCluster:             pulumi.Bool(true),
			NodeType:                pulumi.String("DB-DEV-S"),
			Password:                pulumi.String("thiZ_is_v&ry_s3cret"),
			UserName:                pulumi.String("my_initial_user"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.DatabaseInstance;
import com.pulumi.scaleway.DatabaseInstanceArgs;
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 DatabaseInstance("main", DatabaseInstanceArgs.builder()        
            .backupScheduleFrequency(24)
            .backupScheduleRetention(7)
            .disableBackup(false)
            .engine("PostgreSQL-11")
            .isHaCluster(true)
            .nodeType("DB-DEV-S")
            .password("thiZ_is_v&ry_s3cret")
            .userName("my_initial_user")
            .build());

    }
}

resources:
  main:
    type: scaleway:DatabaseInstance
    properties:
      backupScheduleFrequency: 24
      # every day
      backupScheduleRetention: 7
      # keep it one week
      disableBackup: false
      engine: PostgreSQL-11
      isHaCluster: true
      nodeType: DB-DEV-S
      password: thiZ_is_v&ry_s3cret
      userName: my_initial_user

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

const pn02 = new scaleway.VpcPrivateNetwork("pn02", {});
const mainVpcPublicGatewayDhcp = new scaleway.VpcPublicGatewayDhcp("mainVpcPublicGatewayDhcp", {subnet: "192.168.1.0/24"});
const mainVpcPublicGatewayIp = new scaleway.VpcPublicGatewayIp("mainVpcPublicGatewayIp", {});
const mainVpcPublicGateway = new scaleway.VpcPublicGateway("mainVpcPublicGateway", {
    type: "VPC-GW-S",
    ipId: mainVpcPublicGatewayIp.id,
});
const mainVpcGatewayNetwork = new scaleway.VpcGatewayNetwork("mainVpcGatewayNetwork", {
    gatewayId: mainVpcPublicGateway.id,
    privateNetworkId: pn02.id,
    dhcpId: mainVpcPublicGatewayDhcp.id,
    cleanupDhcp: true,
    enableMasquerade: true,
}, {
    dependsOn: [
        mainVpcPublicGatewayIp,
        pn02,
    ],
});
const mainDatabaseInstance = new scaleway.DatabaseInstance("mainDatabaseInstance", {
    nodeType: "db-dev-s",
    engine: "PostgreSQL-11",
    isHaCluster: false,
    disableBackup: true,
    userName: "my_initial_user",
    password: "thiZ_is_v&ry_s3cret",
    region: "fr-par",
    tags: [
        "terraform-test",
        "scaleway_rdb_instance",
        "volume",
        "rdb_pn",
    ],
    volumeType: "bssd",
    volumeSizeInGb: 10,
    privateNetwork: {
        ipNet: "192.168.1.254/24",
        pnId: pn02.id,
    },
});
const mainVpcPublicGatewayPatRule = new scaleway.VpcPublicGatewayPatRule("mainVpcPublicGatewayPatRule", {
    gatewayId: mainVpcPublicGateway.id,
    privateIp: mainVpcPublicGatewayDhcp.address,
    privatePort: mainDatabaseInstance.privateNetwork.apply(privateNetwork => privateNetwork?.port),
    publicPort: 42,
    protocol: "both",
}, {
    dependsOn: [
        mainVpcGatewayNetwork,
        pn02,
    ],
});

import pulumi
import lbrlabs_pulumi_scaleway as scaleway

pn02 = scaleway.VpcPrivateNetwork("pn02")
main_vpc_public_gateway_dhcp = scaleway.VpcPublicGatewayDhcp("mainVpcPublicGatewayDhcp", subnet="192.168.1.0/24")
main_vpc_public_gateway_ip = scaleway.VpcPublicGatewayIp("mainVpcPublicGatewayIp")
main_vpc_public_gateway = scaleway.VpcPublicGateway("mainVpcPublicGateway",
    type="VPC-GW-S",
    ip_id=main_vpc_public_gateway_ip.id)
main_vpc_gateway_network = scaleway.VpcGatewayNetwork("mainVpcGatewayNetwork",
    gateway_id=main_vpc_public_gateway.id,
    private_network_id=pn02.id,
    dhcp_id=main_vpc_public_gateway_dhcp.id,
    cleanup_dhcp=True,
    enable_masquerade=True,
    opts=pulumi.ResourceOptions(depends_on=[
            main_vpc_public_gateway_ip,
            pn02,
        ]))
main_database_instance = scaleway.DatabaseInstance("mainDatabaseInstance",
    node_type="db-dev-s",
    engine="PostgreSQL-11",
    is_ha_cluster=False,
    disable_backup=True,
    user_name="my_initial_user",
    password="thiZ_is_v&ry_s3cret",
    region="fr-par",
    tags=[
        "terraform-test",
        "scaleway_rdb_instance",
        "volume",
        "rdb_pn",
    ],
    volume_type="bssd",
    volume_size_in_gb=10,
    private_network=scaleway.DatabaseInstancePrivateNetworkArgs(
        ip_net="192.168.1.254/24",
        pn_id=pn02.id,
    ))
main_vpc_public_gateway_pat_rule = scaleway.VpcPublicGatewayPatRule("mainVpcPublicGatewayPatRule",
    gateway_id=main_vpc_public_gateway.id,
    private_ip=main_vpc_public_gateway_dhcp.address,
    private_port=main_database_instance.private_network.port,
    public_port=42,
    protocol="both",
    opts=pulumi.ResourceOptions(depends_on=[
            main_vpc_gateway_network,
            pn02,
        ]))

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

return await Deployment.RunAsync(() => 
{
    var pn02 = new Scaleway.VpcPrivateNetwork("pn02");

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

    var mainVpcPublicGatewayIp = new Scaleway.VpcPublicGatewayIp("mainVpcPublicGatewayIp");

    var mainVpcPublicGateway = new Scaleway.VpcPublicGateway("mainVpcPublicGateway", new()
    {
        Type = "VPC-GW-S",
        IpId = mainVpcPublicGatewayIp.Id,
    });

    var mainVpcGatewayNetwork = new Scaleway.VpcGatewayNetwork("mainVpcGatewayNetwork", new()
    {
        GatewayId = mainVpcPublicGateway.Id,
        PrivateNetworkId = pn02.Id,
        DhcpId = mainVpcPublicGatewayDhcp.Id,
        CleanupDhcp = true,
        EnableMasquerade = true,
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            mainVpcPublicGatewayIp,
            pn02,
        },
    });

    var mainDatabaseInstance = new Scaleway.DatabaseInstance("mainDatabaseInstance", new()
    {
        NodeType = "db-dev-s",
        Engine = "PostgreSQL-11",
        IsHaCluster = false,
        DisableBackup = true,
        UserName = "my_initial_user",
        Password = "thiZ_is_v&ry_s3cret",
        Region = "fr-par",
        Tags = new[]
        {
            "terraform-test",
            "scaleway_rdb_instance",
            "volume",
            "rdb_pn",
        },
        VolumeType = "bssd",
        VolumeSizeInGb = 10,
        PrivateNetwork = new Scaleway.Inputs.DatabaseInstancePrivateNetworkArgs
        {
            IpNet = "192.168.1.254/24",
            PnId = pn02.Id,
        },
    });

    var mainVpcPublicGatewayPatRule = new Scaleway.VpcPublicGatewayPatRule("mainVpcPublicGatewayPatRule", new()
    {
        GatewayId = mainVpcPublicGateway.Id,
        PrivateIp = mainVpcPublicGatewayDhcp.Address,
        PrivatePort = mainDatabaseInstance.PrivateNetwork.Apply(privateNetwork => privateNetwork?.Port),
        PublicPort = 42,
        Protocol = "both",
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            mainVpcGatewayNetwork,
            pn02,
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		pn02, err := scaleway.NewVpcPrivateNetwork(ctx, "pn02", nil)
		if err != nil {
			return err
		}
		mainVpcPublicGatewayDhcp, err := scaleway.NewVpcPublicGatewayDhcp(ctx, "mainVpcPublicGatewayDhcp", &scaleway.VpcPublicGatewayDhcpArgs{
			Subnet: pulumi.String("192.168.1.0/24"),
		})
		if err != nil {
			return err
		}
		mainVpcPublicGatewayIp, err := scaleway.NewVpcPublicGatewayIp(ctx, "mainVpcPublicGatewayIp", nil)
		if err != nil {
			return err
		}
		mainVpcPublicGateway, err := scaleway.NewVpcPublicGateway(ctx, "mainVpcPublicGateway", &scaleway.VpcPublicGatewayArgs{
			Type: pulumi.String("VPC-GW-S"),
			IpId: mainVpcPublicGatewayIp.ID(),
		})
		if err != nil {
			return err
		}
		mainVpcGatewayNetwork, err := scaleway.NewVpcGatewayNetwork(ctx, "mainVpcGatewayNetwork", &scaleway.VpcGatewayNetworkArgs{
			GatewayId:        mainVpcPublicGateway.ID(),
			PrivateNetworkId: pn02.ID(),
			DhcpId:           mainVpcPublicGatewayDhcp.ID(),
			CleanupDhcp:      pulumi.Bool(true),
			EnableMasquerade: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			mainVpcPublicGatewayIp,
			pn02,
		}))
		if err != nil {
			return err
		}
		mainDatabaseInstance, err := scaleway.NewDatabaseInstance(ctx, "mainDatabaseInstance", &scaleway.DatabaseInstanceArgs{
			NodeType:      pulumi.String("db-dev-s"),
			Engine:        pulumi.String("PostgreSQL-11"),
			IsHaCluster:   pulumi.Bool(false),
			DisableBackup: pulumi.Bool(true),
			UserName:      pulumi.String("my_initial_user"),
			Password:      pulumi.String("thiZ_is_v&ry_s3cret"),
			Region:        pulumi.String("fr-par"),
			Tags: pulumi.StringArray{
				pulumi.String("terraform-test"),
				pulumi.String("scaleway_rdb_instance"),
				pulumi.String("volume"),
				pulumi.String("rdb_pn"),
			},
			VolumeType:     pulumi.String("bssd"),
			VolumeSizeInGb: pulumi.Int(10),
			PrivateNetwork: &scaleway.DatabaseInstancePrivateNetworkArgs{
				IpNet: pulumi.String("192.168.1.254/24"),
				PnId:  pn02.ID(),
			},
		})
		if err != nil {
			return err
		}
		_, err = scaleway.NewVpcPublicGatewayPatRule(ctx, "mainVpcPublicGatewayPatRule", &scaleway.VpcPublicGatewayPatRuleArgs{
			GatewayId: mainVpcPublicGateway.ID(),
			PrivateIp: mainVpcPublicGatewayDhcp.Address,
			PrivatePort: mainDatabaseInstance.PrivateNetwork.ApplyT(func(privateNetwork scaleway.DatabaseInstancePrivateNetwork) (*int, error) {
				return &privateNetwork.Port, nil
			}).(pulumi.IntPtrOutput),
			PublicPort: pulumi.Int(42),
			Protocol:   pulumi.String("both"),
		}, pulumi.DependsOn([]pulumi.Resource{
			mainVpcGatewayNetwork,
			pn02,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.VpcPrivateNetwork;
import com.pulumi.scaleway.VpcPublicGatewayDhcp;
import com.pulumi.scaleway.VpcPublicGatewayDhcpArgs;
import com.pulumi.scaleway.VpcPublicGatewayIp;
import com.pulumi.scaleway.VpcPublicGateway;
import com.pulumi.scaleway.VpcPublicGatewayArgs;
import com.pulumi.scaleway.VpcGatewayNetwork;
import com.pulumi.scaleway.VpcGatewayNetworkArgs;
import com.pulumi.scaleway.DatabaseInstance;
import com.pulumi.scaleway.DatabaseInstanceArgs;
import com.pulumi.scaleway.inputs.DatabaseInstancePrivateNetworkArgs;
import com.pulumi.scaleway.VpcPublicGatewayPatRule;
import com.pulumi.scaleway.VpcPublicGatewayPatRuleArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var pn02 = new VpcPrivateNetwork("pn02");

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

        var mainVpcPublicGatewayIp = new VpcPublicGatewayIp("mainVpcPublicGatewayIp");

        var mainVpcPublicGateway = new VpcPublicGateway("mainVpcPublicGateway", VpcPublicGatewayArgs.builder()        
            .type("VPC-GW-S")
            .ipId(mainVpcPublicGatewayIp.id())
            .build());

        var mainVpcGatewayNetwork = new VpcGatewayNetwork("mainVpcGatewayNetwork", VpcGatewayNetworkArgs.builder()        
            .gatewayId(mainVpcPublicGateway.id())
            .privateNetworkId(pn02.id())
            .dhcpId(mainVpcPublicGatewayDhcp.id())
            .cleanupDhcp(true)
            .enableMasquerade(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    mainVpcPublicGatewayIp,
                    pn02)
                .build());

        var mainDatabaseInstance = new DatabaseInstance("mainDatabaseInstance", DatabaseInstanceArgs.builder()        
            .nodeType("db-dev-s")
            .engine("PostgreSQL-11")
            .isHaCluster(false)
            .disableBackup(true)
            .userName("my_initial_user")
            .password("thiZ_is_v&ry_s3cret")
            .region("fr-par")
            .tags(            
                "terraform-test",
                "scaleway_rdb_instance",
                "volume",
                "rdb_pn")
            .volumeType("bssd")
            .volumeSizeInGb(10)
            .privateNetwork(DatabaseInstancePrivateNetworkArgs.builder()
                .ipNet("192.168.1.254/24")
                .pnId(pn02.id())
                .build())
            .build());

        var mainVpcPublicGatewayPatRule = new VpcPublicGatewayPatRule("mainVpcPublicGatewayPatRule", VpcPublicGatewayPatRuleArgs.builder()        
            .gatewayId(mainVpcPublicGateway.id())
            .privateIp(mainVpcPublicGatewayDhcp.address())
            .privatePort(mainDatabaseInstance.privateNetwork().applyValue(privateNetwork -> privateNetwork.port()))
            .publicPort(42)
            .protocol("both")
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    mainVpcGatewayNetwork,
                    pn02)
                .build());

    }
}

resources:
  pn02:
    type: scaleway:VpcPrivateNetwork
  mainVpcPublicGatewayDhcp:
    type: scaleway:VpcPublicGatewayDhcp
    properties:
      subnet: 192.168.1.0/24
  mainVpcPublicGatewayIp:
    type: scaleway:VpcPublicGatewayIp
  mainVpcPublicGateway:
    type: scaleway:VpcPublicGateway
    properties:
      type: VPC-GW-S
      ipId: ${mainVpcPublicGatewayIp.id}
  mainVpcPublicGatewayPatRule:
    type: scaleway:VpcPublicGatewayPatRule
    properties:
      gatewayId: ${mainVpcPublicGateway.id}
      privateIp: ${mainVpcPublicGatewayDhcp.address}
      privatePort: ${mainDatabaseInstance.privateNetwork.port}
      publicPort: 42
      protocol: both
    options:
      dependson:
        - ${mainVpcGatewayNetwork}
        - ${pn02}
  mainVpcGatewayNetwork:
    type: scaleway:VpcGatewayNetwork
    properties:
      gatewayId: ${mainVpcPublicGateway.id}
      privateNetworkId: ${pn02.id}
      dhcpId: ${mainVpcPublicGatewayDhcp.id}
      cleanupDhcp: true
      enableMasquerade: true
    options:
      dependson:
        - ${mainVpcPublicGatewayIp}
        - ${pn02}
  mainDatabaseInstance:
    type: scaleway:DatabaseInstance
    properties:
      nodeType: db-dev-s
      engine: PostgreSQL-11
      isHaCluster: false
      disableBackup: true
      userName: my_initial_user
      password: thiZ_is_v&ry_s3cret
      region: fr-par
      tags:
        - terraform-test
        - scaleway_rdb_instance
        - volume
        - rdb_pn
      volumeType: bssd
      volumeSizeInGb: 10
      privateNetwork:
        ipNet: 192.168.1.254/24
        pnId: ${pn02.id}