upcloud.NetworkPeering

import * as pulumi from "@pulumi/pulumi";
import * as upcloud from "@upcloud/pulumi-upcloud";

// Network peering requires the networks to have routers attached to them.
const _this = new upcloud.Router("this", {name: "network-peering-example-router"});
const example = new upcloud.Network("example", {
    name: "network-peering-example-net",
    zone: "nl-ams1",
    router: exampleUpcloudRouter.id,
    ipNetwork: {
        address: "10.0.0.0/24",
        dhcp: true,
        family: "IPv4",
    },
});
const thisNetworkPeering: upcloud.NetworkPeering[] = [];
for (const range = {value: 0}; range.value < 1; range.value++) {
    thisNetworkPeering.push(new upcloud.NetworkPeering(`this-${range.value}`, {
        name: "network-peering-example-peering",
        network: {
            uuid: example.id,
        },
        peerNetwork: {
            uuid: "0305723a-e5cb-4ef6-985d-e36ed44d133a",
        },
    }));
}

import pulumi
import pulumi_upcloud as upcloud

# Network peering requires the networks to have routers attached to them.
this = upcloud.Router("this", name="network-peering-example-router")
example = upcloud.Network("example",
    name="network-peering-example-net",
    zone="nl-ams1",
    router=example_upcloud_router["id"],
    ip_network={
        "address": "10.0.0.0/24",
        "dhcp": True,
        "family": "IPv4",
    })
this_network_peering = []
for range in [{"value": i} for i in range(0, 1)]:
    this_network_peering.append(upcloud.NetworkPeering(f"this-{range['value']}",
        name="network-peering-example-peering",
        network={
            "uuid": example.id,
        },
        peer_network={
            "uuid": "0305723a-e5cb-4ef6-985d-e36ed44d133a",
        }))

package main

import (
	"github.com/UpCloudLtd/pulumi-upcloud/sdk/go/upcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Network peering requires the networks to have routers attached to them.
		_, err := upcloud.NewRouter(ctx, "this", &upcloud.RouterArgs{
			Name: pulumi.String("network-peering-example-router"),
		})
		if err != nil {
			return err
		}
		example, err := upcloud.NewNetwork(ctx, "example", &upcloud.NetworkArgs{
			Name:   pulumi.String("network-peering-example-net"),
			Zone:   pulumi.String("nl-ams1"),
			Router: pulumi.Any(exampleUpcloudRouter.Id),
			IpNetwork: &upcloud.NetworkIpNetworkArgs{
				Address: pulumi.String("10.0.0.0/24"),
				Dhcp:    pulumi.Bool(true),
				Family:  pulumi.String("IPv4"),
			},
		})
		if err != nil {
			return err
		}
		var thisNetworkPeering []*upcloud.NetworkPeering
		for index := 0; index < 1; index++ {
			key0 := index
			_ := index
			__res, err := upcloud.NewNetworkPeering(ctx, fmt.Sprintf("this-%v", key0), &upcloud.NetworkPeeringArgs{
				Name: pulumi.String("network-peering-example-peering"),
				Network: &upcloud.NetworkPeeringNetworkArgs{
					Uuid: example.ID(),
				},
				PeerNetwork: &upcloud.NetworkPeeringPeerNetworkArgs{
					Uuid: pulumi.String("0305723a-e5cb-4ef6-985d-e36ed44d133a"),
				},
			})
			if err != nil {
				return err
			}
			thisNetworkPeering = append(thisNetworkPeering, __res)
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using UpCloud = UpCloud.Pulumi.UpCloud;

return await Deployment.RunAsync(() => 
{
    // Network peering requires the networks to have routers attached to them.
    var @this = new UpCloud.Router("this", new()
    {
        Name = "network-peering-example-router",
    });

    var example = new UpCloud.Network("example", new()
    {
        Name = "network-peering-example-net",
        Zone = "nl-ams1",
        Router = exampleUpcloudRouter.Id,
        IpNetwork = new UpCloud.Inputs.NetworkIpNetworkArgs
        {
            Address = "10.0.0.0/24",
            Dhcp = true,
            Family = "IPv4",
        },
    });

    var thisNetworkPeering = new List<UpCloud.NetworkPeering>();
    for (var rangeIndex = 0; rangeIndex < 1; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        thisNetworkPeering.Add(new UpCloud.NetworkPeering($"this-{range.Value}", new()
        {
            Name = "network-peering-example-peering",
            Network = new UpCloud.Inputs.NetworkPeeringNetworkArgs
            {
                Uuid = example.Id,
            },
            PeerNetwork = new UpCloud.Inputs.NetworkPeeringPeerNetworkArgs
            {
                Uuid = "0305723a-e5cb-4ef6-985d-e36ed44d133a",
            },
        }));
    }
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.upcloud.Router;
import com.pulumi.upcloud.RouterArgs;
import com.pulumi.upcloud.Network;
import com.pulumi.upcloud.NetworkArgs;
import com.pulumi.upcloud.inputs.NetworkIpNetworkArgs;
import com.pulumi.upcloud.NetworkPeering;
import com.pulumi.upcloud.NetworkPeeringArgs;
import com.pulumi.upcloud.inputs.NetworkPeeringNetworkArgs;
import com.pulumi.upcloud.inputs.NetworkPeeringPeerNetworkArgs;
import com.pulumi.codegen.internal.KeyedValue;
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) {
        // Network peering requires the networks to have routers attached to them.
        var this_ = new Router("this", RouterArgs.builder()
            .name("network-peering-example-router")
            .build());

        var example = new Network("example", NetworkArgs.builder()
            .name("network-peering-example-net")
            .zone("nl-ams1")
            .router(exampleUpcloudRouter.id())
            .ipNetwork(NetworkIpNetworkArgs.builder()
                .address("10.0.0.0/24")
                .dhcp(true)
                .family("IPv4")
                .build())
            .build());

        for (var i = 0; i < 1; i++) {
            new NetworkPeering("thisNetworkPeering-" + i, NetworkPeeringArgs.builder()
                .name("network-peering-example-peering")
                .network(NetworkPeeringNetworkArgs.builder()
                    .uuid(example.id())
                    .build())
                .peerNetwork(NetworkPeeringPeerNetworkArgs.builder()
                    .uuid("0305723a-e5cb-4ef6-985d-e36ed44d133a")
                    .build())
                .build());

        
}
    }
}

resources:
  # Network peering requires the networks to have routers attached to them.
  this:
    type: upcloud:Router
    properties:
      name: network-peering-example-router
  example:
    type: upcloud:Network
    properties:
      name: network-peering-example-net
      zone: nl-ams1
      router: ${exampleUpcloudRouter.id}
      ipNetwork:
        address: 10.0.0.0/24
        dhcp: true
        family: IPv4
  thisNetworkPeering:
    type: upcloud:NetworkPeering
    name: this
    properties:
      name: network-peering-example-peering
      network:
        uuid: ${example.id}
      peerNetwork:
        uuid: 0305723a-e5cb-4ef6-985d-e36ed44d133a
    options: {}

var networkPeeringResource = new UpCloud.NetworkPeering("networkPeeringResource", new()
{
    Network = new UpCloud.Inputs.NetworkPeeringNetworkArgs
    {
        Uuid = "string",
    },
    PeerNetwork = new UpCloud.Inputs.NetworkPeeringPeerNetworkArgs
    {
        Uuid = "string",
    },
    ConfiguredStatus = "string",
    Labels = 
    {
        { "string", "string" },
    },
    Name = "string",
});

example, err := upcloud.NewNetworkPeering(ctx, "networkPeeringResource", &upcloud.NetworkPeeringArgs{
	Network: &upcloud.NetworkPeeringNetworkArgs{
		Uuid: pulumi.String("string"),
	},
	PeerNetwork: &upcloud.NetworkPeeringPeerNetworkArgs{
		Uuid: pulumi.String("string"),
	},
	ConfiguredStatus: pulumi.String("string"),
	Labels: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Name: pulumi.String("string"),
})

var networkPeeringResource = new NetworkPeering("networkPeeringResource", NetworkPeeringArgs.builder()
    .network(NetworkPeeringNetworkArgs.builder()
        .uuid("string")
        .build())
    .peerNetwork(NetworkPeeringPeerNetworkArgs.builder()
        .uuid("string")
        .build())
    .configuredStatus("string")
    .labels(Map.of("string", "string"))
    .name("string")
    .build());

network_peering_resource = upcloud.NetworkPeering("networkPeeringResource",
    network={
        "uuid": "string",
    },
    peer_network={
        "uuid": "string",
    },
    configured_status="string",
    labels={
        "string": "string",
    },
    name="string")

const networkPeeringResource = new upcloud.NetworkPeering("networkPeeringResource", {
    network: {
        uuid: "string",
    },
    peerNetwork: {
        uuid: "string",
    },
    configuredStatus: "string",
    labels: {
        string: "string",
    },
    name: "string",
});

type: upcloud:NetworkPeering
properties:
    configuredStatus: string
    labels:
        string: string
    name: string
    network:
        uuid: string
    peerNetwork:
        uuid: string