netbox.DevicePrimaryIp

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", {
    deviceTypeId: netbox_device_type.test.id,
    roleId: netbox_device_role.test.id,
    siteId: netbox_site.test.id,
});
const testV4IpAddress = new netbox.IpAddress("testV4IpAddress", {
    ipAddress: "1.1.1.1/32",
    status: "active",
    deviceInterfaceId: netbox_device_interface.test.id,
});
const testV4DevicePrimaryIp = new netbox.DevicePrimaryIp("testV4DevicePrimaryIp", {
    deviceId: test.deviceId,
    ipAddressId: netbox_ip_address.test.id,
});

import pulumi
import pulumi_netbox as netbox

# Note that some terraform code is not included in the example for brevity
test = netbox.Device("test",
    device_type_id=netbox_device_type["test"]["id"],
    role_id=netbox_device_role["test"]["id"],
    site_id=netbox_site["test"]["id"])
test_v4_ip_address = netbox.IpAddress("testV4IpAddress",
    ip_address="1.1.1.1/32",
    status="active",
    device_interface_id=netbox_device_interface["test"]["id"])
test_v4_device_primary_ip = netbox.DevicePrimaryIp("testV4DevicePrimaryIp",
    device_id=test.device_id,
    ip_address_id=netbox_ip_address["test"]["id"])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/netbox/v3/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{
			DeviceTypeId: pulumi.Any(netbox_device_type.Test.Id),
			RoleId:       pulumi.Any(netbox_device_role.Test.Id),
			SiteId:       pulumi.Any(netbox_site.Test.Id),
		})
		if err != nil {
			return err
		}
		_, err = netbox.NewIpAddress(ctx, "testV4IpAddress", &netbox.IpAddressArgs{
			IpAddress:         pulumi.String("1.1.1.1/32"),
			Status:            pulumi.String("active"),
			DeviceInterfaceId: pulumi.Any(netbox_device_interface.Test.Id),
		})
		if err != nil {
			return err
		}
		_, err = netbox.NewDevicePrimaryIp(ctx, "testV4DevicePrimaryIp", &netbox.DevicePrimaryIpArgs{
			DeviceId:    test.DeviceId,
			IpAddressId: pulumi.Any(netbox_ip_address.Test.Id),
		})
		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()
    {
        DeviceTypeId = netbox_device_type.Test.Id,
        RoleId = netbox_device_role.Test.Id,
        SiteId = netbox_site.Test.Id,
    });

    var testV4IpAddress = new Netbox.IpAddress("testV4IpAddress", new()
    {
        IpAddress = "1.1.1.1/32",
        Status = "active",
        DeviceInterfaceId = netbox_device_interface.Test.Id,
    });

    var testV4DevicePrimaryIp = new Netbox.DevicePrimaryIp("testV4DevicePrimaryIp", new()
    {
        DeviceId = test.DeviceId,
        IpAddressId = netbox_ip_address.Test.Id,
    });

});

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.DevicePrimaryIp;
import com.pulumi.netbox.DevicePrimaryIpArgs;
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()
            .deviceTypeId(netbox_device_type.test().id())
            .roleId(netbox_device_role.test().id())
            .siteId(netbox_site.test().id())
            .build());

        var testV4IpAddress = new IpAddress("testV4IpAddress", IpAddressArgs.builder()
            .ipAddress("1.1.1.1/32")
            .status("active")
            .deviceInterfaceId(netbox_device_interface.test().id())
            .build());

        var testV4DevicePrimaryIp = new DevicePrimaryIp("testV4DevicePrimaryIp", DevicePrimaryIpArgs.builder()
            .deviceId(test.deviceId())
            .ipAddressId(netbox_ip_address.test().id())
            .build());

    }
}

resources:
  # Note that some terraform code is not included in the example for brevity
  test:
    type: netbox:Device
    properties:
      deviceTypeId: ${netbox_device_type.test.id}
      roleId: ${netbox_device_role.test.id}
      siteId: ${netbox_site.test.id}
  testV4IpAddress:
    type: netbox:IpAddress
    properties:
      ipAddress: 1.1.1.1/32
      status: active
      deviceInterfaceId: ${netbox_device_interface.test.id}
  testV4DevicePrimaryIp:
    type: netbox:DevicePrimaryIp
    properties:
      deviceId: ${test.deviceId}
      ipAddressId: ${netbox_ip_address.test.id}

var devicePrimaryIpResource = new Netbox.DevicePrimaryIp("devicePrimaryIpResource", new()
{
    DeviceId = 0,
    IpAddressId = 0,
    DevicePrimaryIpId = "string",
    IpAddressVersion = 0,
});

example, err := netbox.NewDevicePrimaryIp(ctx, "devicePrimaryIpResource", &netbox.DevicePrimaryIpArgs{
	DeviceId:          pulumi.Float64(0),
	IpAddressId:       pulumi.Float64(0),
	DevicePrimaryIpId: pulumi.String("string"),
	IpAddressVersion:  pulumi.Float64(0),
})

var devicePrimaryIpResource = new DevicePrimaryIp("devicePrimaryIpResource", DevicePrimaryIpArgs.builder()
    .deviceId(0)
    .ipAddressId(0)
    .devicePrimaryIpId("string")
    .ipAddressVersion(0)
    .build());

device_primary_ip_resource = netbox.DevicePrimaryIp("devicePrimaryIpResource",
    device_id=0,
    ip_address_id=0,
    device_primary_ip_id="string",
    ip_address_version=0)

const devicePrimaryIpResource = new netbox.DevicePrimaryIp("devicePrimaryIpResource", {
    deviceId: 0,
    ipAddressId: 0,
    devicePrimaryIpId: "string",
    ipAddressVersion: 0,
});

type: netbox:DevicePrimaryIp
properties:
    deviceId: 0
    devicePrimaryIpId: string
    ipAddressId: 0
    ipAddressVersion: 0