linode.Ipv6Range

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

const foobar = new linode.Instance("foobar", {
    label: "my-linode",
    image: "linode/alpine3.19",
    type: "g6-nanode-1",
    region: "us-southeast",
});
const foobarIpv6Range = new linode.Ipv6Range("foobar", {
    linodeId: foobar.id,
    prefixLength: 64,
});

import pulumi
import pulumi_linode as linode

foobar = linode.Instance("foobar",
    label="my-linode",
    image="linode/alpine3.19",
    type="g6-nanode-1",
    region="us-southeast")
foobar_ipv6_range = linode.Ipv6Range("foobar",
    linode_id=foobar.id,
    prefix_length=64)

package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v4/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foobar, err := linode.NewInstance(ctx, "foobar", &linode.InstanceArgs{
			Label:  pulumi.String("my-linode"),
			Image:  pulumi.String("linode/alpine3.19"),
			Type:   pulumi.String("g6-nanode-1"),
			Region: pulumi.String("us-southeast"),
		})
		if err != nil {
			return err
		}
		_, err = linode.NewIpv6Range(ctx, "foobar", &linode.Ipv6RangeArgs{
			LinodeId:     foobar.ID(),
			PrefixLength: pulumi.Int(64),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var foobar = new Linode.Instance("foobar", new()
    {
        Label = "my-linode",
        Image = "linode/alpine3.19",
        Type = "g6-nanode-1",
        Region = "us-southeast",
    });

    var foobarIpv6Range = new Linode.Ipv6Range("foobar", new()
    {
        LinodeId = foobar.Id,
        PrefixLength = 64,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.Instance;
import com.pulumi.linode.InstanceArgs;
import com.pulumi.linode.Ipv6Range;
import com.pulumi.linode.Ipv6RangeArgs;
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 foobar = new Instance("foobar", InstanceArgs.builder()
            .label("my-linode")
            .image("linode/alpine3.19")
            .type("g6-nanode-1")
            .region("us-southeast")
            .build());

        var foobarIpv6Range = new Ipv6Range("foobarIpv6Range", Ipv6RangeArgs.builder()
            .linodeId(foobar.id())
            .prefixLength(64)
            .build());

    }
}

resources:
  foobar:
    type: linode:Instance
    properties:
      label: my-linode
      image: linode/alpine3.19
      type: g6-nanode-1
      region: us-southeast
  foobarIpv6Range:
    type: linode:Ipv6Range
    name: foobar
    properties:
      linodeId: ${foobar.id}
      prefixLength: 64

var ipv6RangeResource = new Linode.Ipv6Range("ipv6RangeResource", new()
{
    PrefixLength = 0,
    LinodeId = 0,
    RouteTarget = "string",
});

example, err := linode.NewIpv6Range(ctx, "ipv6RangeResource", &linode.Ipv6RangeArgs{
	PrefixLength: pulumi.Int(0),
	LinodeId:     pulumi.Int(0),
	RouteTarget:  pulumi.String("string"),
})

var ipv6RangeResource = new Ipv6Range("ipv6RangeResource", Ipv6RangeArgs.builder()
    .prefixLength(0)
    .linodeId(0)
    .routeTarget("string")
    .build());

ipv6_range_resource = linode.Ipv6Range("ipv6RangeResource",
    prefix_length=0,
    linode_id=0,
    route_target="string")

const ipv6RangeResource = new linode.Ipv6Range("ipv6RangeResource", {
    prefixLength: 0,
    linodeId: 0,
    routeTarget: "string",
});

type: linode:Ipv6Range
properties:
    linodeId: 0
    prefixLength: 0
    routeTarget: string