netbox.DeviceOobIp

import * as pulumi from "@pulumi/pulumi";
import * as netbox from "@pulumi/netbox";

// Note that some terraform code is not included in the example for brevity
const test = new netbox.Device("test", {
    name: "%[1]s",
    deviceTypeId: testNetboxDeviceType.id,
    roleId: testNetboxDeviceRole.id,
    siteId: testNetboxSite.id,
});
const oob = new netbox.IpAddress("oob", {
    ipAddress: "10.0.0.5/24",
    status: "active",
    deviceInterfaceId: testNetboxDeviceInterface.id,
});
const testDeviceOobIp = new netbox.DeviceOobIp("test", {
    deviceId: test.deviceId,
    ipAddressId: oob.ipAddressId,
});

import pulumi
import pulumi_netbox as netbox

# Note that some terraform code is not included in the example for brevity
test = netbox.Device("test",
    name="%[1]s",
    device_type_id=test_netbox_device_type["id"],
    role_id=test_netbox_device_role["id"],
    site_id=test_netbox_site["id"])
oob = netbox.IpAddress("oob",
    ip_address="10.0.0.5/24",
    status="active",
    device_interface_id=test_netbox_device_interface["id"])
test_device_oob_ip = netbox.DeviceOobIp("test",
    device_id=test.device_id,
    ip_address_id=oob.ip_address_id)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/netbox/v5/netbox"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Note that some terraform code is not included in the example for brevity
		test, err := netbox.NewDevice(ctx, "test", &netbox.DeviceArgs{
			Name:         pulumi.String("%[1]s"),
			DeviceTypeId: pulumi.Any(testNetboxDeviceType.Id),
			RoleId:       pulumi.Any(testNetboxDeviceRole.Id),
			SiteId:       pulumi.Any(testNetboxSite.Id),
		})
		if err != nil {
			return err
		}
		oob, err := netbox.NewIpAddress(ctx, "oob", &netbox.IpAddressArgs{
			IpAddress:         pulumi.String("10.0.0.5/24"),
			Status:            pulumi.String("active"),
			DeviceInterfaceId: pulumi.Any(testNetboxDeviceInterface.Id),
		})
		if err != nil {
			return err
		}
		_, err = netbox.NewDeviceOobIp(ctx, "test", &netbox.DeviceOobIpArgs{
			DeviceId:    test.DeviceId,
			IpAddressId: oob.IpAddressId,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Note that some terraform code is not included in the example for brevity
    var test = new Netbox.Device("test", new()
    {
        Name = "%[1]s",
        DeviceTypeId = testNetboxDeviceType.Id,
        RoleId = testNetboxDeviceRole.Id,
        SiteId = testNetboxSite.Id,
    });

    var oob = new Netbox.IpAddress("oob", new()
    {
        IpAddress = "10.0.0.5/24",
        Status = "active",
        DeviceInterfaceId = testNetboxDeviceInterface.Id,
    });

    var testDeviceOobIp = new Netbox.DeviceOobIp("test", new()
    {
        DeviceId = test.DeviceId,
        IpAddressId = oob.IpAddressId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.netbox.Device;
import com.pulumi.netbox.DeviceArgs;
import com.pulumi.netbox.IpAddress;
import com.pulumi.netbox.IpAddressArgs;
import com.pulumi.netbox.DeviceOobIp;
import com.pulumi.netbox.DeviceOobIpArgs;
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) {
        // Note that some terraform code is not included in the example for brevity
        var test = new Device("test", DeviceArgs.builder()
            .name("%[1]s")
            .deviceTypeId(testNetboxDeviceType.id())
            .roleId(testNetboxDeviceRole.id())
            .siteId(testNetboxSite.id())
            .build());

        var oob = new IpAddress("oob", IpAddressArgs.builder()
            .ipAddress("10.0.0.5/24")
            .status("active")
            .deviceInterfaceId(testNetboxDeviceInterface.id())
            .build());

        var testDeviceOobIp = new DeviceOobIp("testDeviceOobIp", DeviceOobIpArgs.builder()
            .deviceId(test.deviceId())
            .ipAddressId(oob.ipAddressId())
            .build());

    }
}

resources:
  # Note that some terraform code is not included in the example for brevity
  test:
    type: netbox:Device
    properties:
      name: '%[1]s'
      deviceTypeId: ${testNetboxDeviceType.id}
      roleId: ${testNetboxDeviceRole.id}
      siteId: ${testNetboxSite.id}
  oob:
    type: netbox:IpAddress
    properties:
      ipAddress: 10.0.0.5/24
      status: active
      deviceInterfaceId: ${testNetboxDeviceInterface.id}
  testDeviceOobIp:
    type: netbox:DeviceOobIp
    name: test
    properties:
      deviceId: ${test.deviceId}
      ipAddressId: ${oob.ipAddressId}

var deviceOobIpResource = new Netbox.DeviceOobIp("deviceOobIpResource", new()
{
    DeviceId = 0,
    IpAddressId = 0,
    DeviceOobIpId = "string",
});

example, err := netbox.NewDeviceOobIp(ctx, "deviceOobIpResource", &netbox.DeviceOobIpArgs{
	DeviceId:      pulumi.Float64(0),
	IpAddressId:   pulumi.Float64(0),
	DeviceOobIpId: pulumi.String("string"),
})

resource "netbox_device_oob_ip" "deviceOobIpResource" {
  lifecycle {
    create_before_destroy = true
  }
  device_id        = 0
  ip_address_id    = 0
  device_oob_ip_id = "string"
}

var deviceOobIpResource = new DeviceOobIp("deviceOobIpResource", DeviceOobIpArgs.builder()
    .deviceId(0.0)
    .ipAddressId(0.0)
    .deviceOobIpId("string")
    .build());

device_oob_ip_resource = netbox.DeviceOobIp("deviceOobIpResource",
    device_id=float(0),
    ip_address_id=float(0),
    device_oob_ip_id="string")

const deviceOobIpResource = new netbox.DeviceOobIp("deviceOobIpResource", {
    deviceId: 0,
    ipAddressId: 0,
    deviceOobIpId: "string",
});

type: netbox:DeviceOobIp
properties:
    deviceId: 0
    deviceOobIpId: string
    ipAddressId: 0