Sign in Dashboard Get started
  1. Packages
  2. Packages
  3. Newrelic Provider
  4. API Docs
  5. FleetMembers
Viewing docs for New Relic v5.69.0
published on Monday, May 25, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-newrelic

newrelic.FleetMembers

newrelic logo
Viewing docs for New Relic v5.69.0
published on Monday, May 25, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-newrelic

    Use this resource to manage entity assignments across one or more rings of a New Relic Fleet. Each resource instance is scoped to a single fleet and may declare any number of ring blocks, one per ring to manage.

    Note This resource requires access to the New Relic Fleet Control API. Ensure the API key provided to the provider has the necessary Fleet Control permissions.

    How membership management works

    Entities can join a fleet ring through two independent paths:

    1. Agent Control instrumentation — when an entity is instrumented with Agent Control and associated with a fleet, the platform assigns it to the fleet automatically. These entities are outside of Terraform’s control unless explicitly declared (see Adopting Agent Control entities below).

    2. Explicit assignment — this resource manages entities via the FleetControlAddFleetMembers and FleetControlRemoveFleetMembers API mutations. Only entities listed in entityIds are tracked.

    This resource operates on an opt-in management model: it tracks only the entities explicitly declared in each ring block. Entities present in a ring through any other means—including Agent Control instrumentation—are not visible to Terraform, are never reported as drift, and are never removed by this resource — unless they are explicitly added to entityIds, at which point they come under full Terraform lifecycle management and can be removed from a ring or moved to another ring on the next apply.

    Warning reference

    The following warnings may appear during plan or apply operations:

    Entities already assigned in fleet

    Warning: Entities already assigned in fleet — skipped add for ring "default"

    This warning fires during create or update when one or more entities listed in entityIds are already assigned somewhere in the fleet (including in a different ring, or via Agent Control). The API rejects duplicate add requests, so the affected entities are skipped for the add mutation. However, if those entities are already in the target ring, they are confirmed by the subsequent read and adopted into Terraform state. From that point on, Terraform manages their lifecycle: removing them from entityIds will remove them from the fleet ring on the next apply.

    If an entity is in a different ring than the one declared, it must first be removed from that ring before it can be reassigned. The warning message identifies the affected entity GUIDs and indicates which ring they were targeted for.

    Fleet members removed outside Terraform

    Warning: Fleet members removed outside Terraform in ring "default"

    This warning fires during plan or apply when an entity listed in entityIds is no longer present in the ring according to the API. This indicates out-of-band drift—the entity was removed from the ring by a process other than Terraform. The next apply will re-add the entity to restore the declared state. To accept the removal instead, remove the entity GUID from entityIds and apply again.

    A second plan after apply will confirm the state is clean once API-side changes have propagated.

    Example Usage

    Single ring

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

const example = new newrelic.Fleet("example", {
    name: "my-fleet",
    managedEntityType: "HOST",
    operatingSystem: "LINUX",
});
const exampleFleetMembers = new newrelic.FleetMembers("example", {
    fleetId: example.id,
    rings: [{
        name: "default",
        entityIds: [
            "MXxOR0VQfEhPU1R8MTIzNDU2Nzg",
            "MXxOR0VQfEhPU1R8ODc2NTQzMjE",
        ],
    }],
});

    import pulumi
import pulumi_newrelic as newrelic

example = newrelic.Fleet("example",
    name="my-fleet",
    managed_entity_type="HOST",
    operating_system="LINUX")
example_fleet_members = newrelic.FleetMembers("example",
    fleet_id=example.id,
    rings=[{
        "name": "default",
        "entity_ids": [
            "MXxOR0VQfEhPU1R8MTIzNDU2Nzg",
            "MXxOR0VQfEhPU1R8ODc2NTQzMjE",
        ],
    }])

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := newrelic.NewFleet(ctx, "example", &newrelic.FleetArgs{
			Name:              pulumi.String("my-fleet"),
			ManagedEntityType: pulumi.String("HOST"),
			OperatingSystem:   pulumi.String("LINUX"),
		})
		if err != nil {
			return err
		}
		_, err = newrelic.NewFleetMembers(ctx, "example", &newrelic.FleetMembersArgs{
			FleetId: example.ID(),
			Rings: newrelic.FleetMembersRingArray{
				&newrelic.FleetMembersRingArgs{
					Name: pulumi.String("default"),
					EntityIds: pulumi.StringArray{
						pulumi.String("MXxOR0VQfEhPU1R8MTIzNDU2Nzg"),
						pulumi.String("MXxOR0VQfEhPU1R8ODc2NTQzMjE"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new NewRelic.Fleet("example", new()
    {
        Name = "my-fleet",
        ManagedEntityType = "HOST",
        OperatingSystem = "LINUX",
    });

    var exampleFleetMembers = new NewRelic.FleetMembers("example", new()
    {
        FleetId = example.Id,
        Rings = new[]
        {
            new NewRelic.Inputs.FleetMembersRingArgs
            {
                Name = "default",
                EntityIds = new[]
                {
                    "MXxOR0VQfEhPU1R8MTIzNDU2Nzg",
                    "MXxOR0VQfEhPU1R8ODc2NTQzMjE",
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.Fleet;
import com.pulumi.newrelic.FleetArgs;
import com.pulumi.newrelic.FleetMembers;
import com.pulumi.newrelic.FleetMembersArgs;
import com.pulumi.newrelic.inputs.FleetMembersRingArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new Fleet("example", FleetArgs.builder()
            .name("my-fleet")
            .managedEntityType("HOST")
            .operatingSystem("LINUX")
            .build());

        var exampleFleetMembers = new FleetMembers("exampleFleetMembers", FleetMembersArgs.builder()
            .fleetId(example.id())
            .rings(FleetMembersRingArgs.builder()
                .name("default")
                .entityIds(                
                    "MXxOR0VQfEhPU1R8MTIzNDU2Nzg",
                    "MXxOR0VQfEhPU1R8ODc2NTQzMjE")
                .build())
            .build());

    }
}

    resources:
  example:
    type: newrelic:Fleet
    properties:
      name: my-fleet
      managedEntityType: HOST
      operatingSystem: LINUX
  exampleFleetMembers:
    type: newrelic:FleetMembers
    name: example
    properties:
      fleetId: ${example.id}
      rings:
        - name: default
          entityIds:
            - MXxOR0VQfEhPU1R8MTIzNDU2Nzg
            - MXxOR0VQfEhPU1R8ODc2NTQzMjE

    pulumi {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_fleet" "example" {
  name                = "my-fleet"
  managed_entity_type = "HOST"
  operating_system    = "LINUX"
}
resource "newrelic_fleetmembers" "example" {
  fleet_id = newrelic_fleet.example.id
  rings {
    name       = "default"
    entity_ids = ["MXxOR0VQfEhPU1R8MTIzNDU2Nzg", "MXxOR0VQfEhPU1R8ODc2NTQzMjE"]
  }
}

    Multiple rings

    Multiple ring blocks can be declared within a single resource instance to manage entity assignments across rings in one operation. Moving an entity from one ring to another is handled by updating the entityIds lists in both ring blocks and applying in a single step.

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

const example = new newrelic.FleetMembers("example", {
    fleetId: exampleNewrelicFleet.id,
    rings: [
        {
            name: "default",
            entityIds: ["MXxOR0VQfEhPU1R8MTIzNDU2Nzg"],
        },
        {
            name: "canary",
            entityIds: [
                "MXxOR0VQfEhPU1R8ODc2NTQzMjE",
                "MXxOR0VQfEhPU1R8OTk5ODc2NTQ",
            ],
        },
    ],
});

    import pulumi
import pulumi_newrelic as newrelic

example = newrelic.FleetMembers("example",
    fleet_id=example_newrelic_fleet["id"],
    rings=[
        {
            "name": "default",
            "entity_ids": ["MXxOR0VQfEhPU1R8MTIzNDU2Nzg"],
        },
        {
            "name": "canary",
            "entity_ids": [
                "MXxOR0VQfEhPU1R8ODc2NTQzMjE",
                "MXxOR0VQfEhPU1R8OTk5ODc2NTQ",
            ],
        },
    ])

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewFleetMembers(ctx, "example", &newrelic.FleetMembersArgs{
			FleetId: pulumi.Any(exampleNewrelicFleet.Id),
			Rings: newrelic.FleetMembersRingArray{
				&newrelic.FleetMembersRingArgs{
					Name: pulumi.String("default"),
					EntityIds: pulumi.StringArray{
						pulumi.String("MXxOR0VQfEhPU1R8MTIzNDU2Nzg"),
					},
				},
				&newrelic.FleetMembersRingArgs{
					Name: pulumi.String("canary"),
					EntityIds: pulumi.StringArray{
						pulumi.String("MXxOR0VQfEhPU1R8ODc2NTQzMjE"),
						pulumi.String("MXxOR0VQfEhPU1R8OTk5ODc2NTQ"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new NewRelic.FleetMembers("example", new()
    {
        FleetId = exampleNewrelicFleet.Id,
        Rings = new[]
        {
            new NewRelic.Inputs.FleetMembersRingArgs
            {
                Name = "default",
                EntityIds = new[]
                {
                    "MXxOR0VQfEhPU1R8MTIzNDU2Nzg",
                },
            },
            new NewRelic.Inputs.FleetMembersRingArgs
            {
                Name = "canary",
                EntityIds = new[]
                {
                    "MXxOR0VQfEhPU1R8ODc2NTQzMjE",
                    "MXxOR0VQfEhPU1R8OTk5ODc2NTQ",
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.FleetMembers;
import com.pulumi.newrelic.FleetMembersArgs;
import com.pulumi.newrelic.inputs.FleetMembersRingArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new FleetMembers("example", FleetMembersArgs.builder()
            .fleetId(exampleNewrelicFleet.id())
            .rings(            
                FleetMembersRingArgs.builder()
                    .name("default")
                    .entityIds("MXxOR0VQfEhPU1R8MTIzNDU2Nzg")
                    .build(),
                FleetMembersRingArgs.builder()
                    .name("canary")
                    .entityIds(                    
                        "MXxOR0VQfEhPU1R8ODc2NTQzMjE",
                        "MXxOR0VQfEhPU1R8OTk5ODc2NTQ")
                    .build())
            .build());

    }
}

    resources:
  example:
    type: newrelic:FleetMembers
    properties:
      fleetId: ${exampleNewrelicFleet.id}
      rings:
        - name: default
          entityIds:
            - MXxOR0VQfEhPU1R8MTIzNDU2Nzg
        - name: canary
          entityIds:
            - MXxOR0VQfEhPU1R8ODc2NTQzMjE
            - MXxOR0VQfEhPU1R8OTk5ODc2NTQ

    pulumi {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_fleetmembers" "example" {
  fleet_id = exampleNewrelicFleet.id
  rings {
    name       = "default"
    entity_ids = ["MXxOR0VQfEhPU1R8MTIzNDU2Nzg"]
  }
  rings {
    name       = "canary"
    entity_ids = ["MXxOR0VQfEhPU1R8ODc2NTQzMjE", "MXxOR0VQfEhPU1R8OTk5ODc2NTQ"]
  }
}

    Adopting Agent Control entities

    To bring an entity that joined via Agent Control under Terraform management, add its GUID to entityIds. A warning will indicate that the entity is already assigned in the fleet and was skipped during the add mutation. The entity is then confirmed by the subsequent read and adopted into state. Subsequent plans will be no-ops, and destroying the resource (or removing the GUID from entityIds) will remove the entity from the fleet ring.

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

const example = new newrelic.FleetMembers("example", {
    fleetId: exampleNewrelicFleet.id,
    rings: [{
        name: "default",
        entityIds: [
            "MXxOR0VQfEhPU1R8MTIzNDU2Nzg",
            "MXxOR0VQfEhPU1R8ODc2NTQzMjE",
        ],
    }],
});

    import pulumi
import pulumi_newrelic as newrelic

example = newrelic.FleetMembers("example",
    fleet_id=example_newrelic_fleet["id"],
    rings=[{
        "name": "default",
        "entity_ids": [
            "MXxOR0VQfEhPU1R8MTIzNDU2Nzg",
            "MXxOR0VQfEhPU1R8ODc2NTQzMjE",
        ],
    }])

    package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewFleetMembers(ctx, "example", &newrelic.FleetMembersArgs{
			FleetId: pulumi.Any(exampleNewrelicFleet.Id),
			Rings: newrelic.FleetMembersRingArray{
				&newrelic.FleetMembersRingArgs{
					Name: pulumi.String("default"),
					EntityIds: pulumi.StringArray{
						pulumi.String("MXxOR0VQfEhPU1R8MTIzNDU2Nzg"),
						pulumi.String("MXxOR0VQfEhPU1R8ODc2NTQzMjE"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new NewRelic.FleetMembers("example", new()
    {
        FleetId = exampleNewrelicFleet.Id,
        Rings = new[]
        {
            new NewRelic.Inputs.FleetMembersRingArgs
            {
                Name = "default",
                EntityIds = new[]
                {
                    "MXxOR0VQfEhPU1R8MTIzNDU2Nzg",
                    "MXxOR0VQfEhPU1R8ODc2NTQzMjE",
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.FleetMembers;
import com.pulumi.newrelic.FleetMembersArgs;
import com.pulumi.newrelic.inputs.FleetMembersRingArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new FleetMembers("example", FleetMembersArgs.builder()
            .fleetId(exampleNewrelicFleet.id())
            .rings(FleetMembersRingArgs.builder()
                .name("default")
                .entityIds(                
                    "MXxOR0VQfEhPU1R8MTIzNDU2Nzg",
                    "MXxOR0VQfEhPU1R8ODc2NTQzMjE")
                .build())
            .build());

    }
}

    resources:
  example:
    type: newrelic:FleetMembers
    properties:
      fleetId: ${exampleNewrelicFleet.id}
      rings:
        - name: default
          entityIds:
            - MXxOR0VQfEhPU1R8MTIzNDU2Nzg
            - MXxOR0VQfEhPU1R8ODc2NTQzMjE

    pulumi {
  required_providers {
    newrelic = {
      source = "pulumi/newrelic"
    }
  }
}

resource "newrelic_fleetmembers" "example" {
  fleet_id = exampleNewrelicFleet.id
  rings {
    name       = "default"
    entity_ids = ["MXxOR0VQfEhPU1R8MTIzNDU2Nzg", "MXxOR0VQfEhPU1R8ODc2NTQzMjE"]
  }
}

    Drift Detection

    On each plan or refresh, this resource queries the current membership of each declared ring and compares it against the entity GUIDs in state. If any declared entity is no longer present in the ring, a warning is emitted and the pending plan will include a change to re-add it. If the removal was intentional, remove the GUID from entityIds to silence the warning and prevent re-addition.

    Entities present in the ring but not declared in entityIds are never surfaced as drift.

    Create FleetMembers Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new FleetMembers(name: string, args: FleetMembersArgs, opts?: CustomResourceOptions);
    @overload
def FleetMembers(resource_name: str,
                 args: FleetMembersArgs,
                 opts: Optional[ResourceOptions] = None)

@overload
def FleetMembers(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 fleet_id: Optional[str] = None,
                 rings: Optional[Sequence[FleetMembersRingArgs]] = None)
    func NewFleetMembers(ctx *Context, name string, args FleetMembersArgs, opts ...ResourceOption) (*FleetMembers, error)
    public FleetMembers(string name, FleetMembersArgs args, CustomResourceOptions? opts = null)
    public FleetMembers(String name, FleetMembersArgs args)
public FleetMembers(String name, FleetMembersArgs args, CustomResourceOptions options)

    type: newrelic:FleetMembers
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "newrelic_fleetmembers" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args FleetMembersArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args FleetMembersArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args FleetMembersArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args FleetMembersArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args FleetMembersArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var fleetMembersResource = new NewRelic.FleetMembers("fleetMembersResource", new()
{
    FleetId = "string",
    Rings = new[]
    {
        new NewRelic.Inputs.FleetMembersRingArgs
        {
            EntityIds = new[]
            {
                "string",
            },
            Name = "string",
        },
    },
});

    example, err := newrelic.NewFleetMembers(ctx, "fleetMembersResource", &newrelic.FleetMembersArgs{
	FleetId: pulumi.String("string"),
	Rings: newrelic.FleetMembersRingArray{
		&newrelic.FleetMembersRingArgs{
			EntityIds: pulumi.StringArray{
				pulumi.String("string"),
			},
			Name: pulumi.String("string"),
		},
	},
})

    resource "newrelic_fleetmembers" "fleetMembersResource" {
  fleet_id = "string"
  rings {
    entity_ids = ["string"]
    name       = "string"
  }
}

    var fleetMembersResource = new FleetMembers("fleetMembersResource", FleetMembersArgs.builder()
    .fleetId("string")
    .rings(FleetMembersRingArgs.builder()
        .entityIds("string")
        .name("string")
        .build())
    .build());

    fleet_members_resource = newrelic.FleetMembers("fleetMembersResource",
    fleet_id="string",
    rings=[{
        "entity_ids": ["string"],
        "name": "string",
    }])

    const fleetMembersResource = new newrelic.FleetMembers("fleetMembersResource", {
    fleetId: "string",
    rings: [{
        entityIds: ["string"],
        name: "string",
    }],
});

    type: newrelic:FleetMembers
properties:
    fleetId: string
    rings:
        - entityIds:
            - string
          name: string

    FleetMembers Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The FleetMembers resource accepts the following input properties:

    FleetId string
    The GUID of the fleet to manage entity assignments for.
    Rings List<Pulumi.NewRelic.Inputs.FleetMembersRing>
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    FleetId string
    The GUID of the fleet to manage entity assignments for.
    Rings []FleetMembersRingArgs
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    fleet_id string
    The GUID of the fleet to manage entity assignments for.
    rings list(object)
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    fleetId String
    The GUID of the fleet to manage entity assignments for.
    rings List<FleetMembersRing>
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    fleetId string
    The GUID of the fleet to manage entity assignments for.
    rings FleetMembersRing[]
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    fleet_id str
    The GUID of the fleet to manage entity assignments for.
    rings Sequence[FleetMembersRingArgs]
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    fleetId String
    The GUID of the fleet to manage entity assignments for.
    rings List<Property Map>
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:

    Outputs

    All input properties are implicitly available as output properties. Additionally, the FleetMembers resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing FleetMembers Resource

    Get an existing FleetMembers resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: FleetMembersState, opts?: CustomResourceOptions): FleetMembers
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        fleet_id: Optional[str] = None,
        rings: Optional[Sequence[FleetMembersRingArgs]] = None) -> FleetMembers
    func GetFleetMembers(ctx *Context, name string, id IDInput, state *FleetMembersState, opts ...ResourceOption) (*FleetMembers, error)
    public static FleetMembers Get(string name, Input<string> id, FleetMembersState? state, CustomResourceOptions? opts = null)
    public static FleetMembers get(String name, Output<String> id, FleetMembersState state, CustomResourceOptions options)
    resources:  _:    type: newrelic:FleetMembers    get:      id: ${id}
    import {
  to = newrelic_fleetmembers.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    FleetId string
    The GUID of the fleet to manage entity assignments for.
    Rings List<Pulumi.NewRelic.Inputs.FleetMembersRing>
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    FleetId string
    The GUID of the fleet to manage entity assignments for.
    Rings []FleetMembersRingArgs
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    fleet_id string
    The GUID of the fleet to manage entity assignments for.
    rings list(object)
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    fleetId String
    The GUID of the fleet to manage entity assignments for.
    rings List<FleetMembersRing>
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    fleetId string
    The GUID of the fleet to manage entity assignments for.
    rings FleetMembersRing[]
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    fleet_id str
    The GUID of the fleet to manage entity assignments for.
    rings Sequence[FleetMembersRingArgs]
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:
    fleetId String
    The GUID of the fleet to manage entity assignments for.
    rings List<Property Map>
    One or more ring blocks. Each block declares which entities Terraform should maintain in that ring. At least one ring block must be specified. The following arguments are supported within each ring block:

    Supporting Types

    FleetMembersRing, FleetMembersRingArgs

    EntityIds List<string>
    An ordered list of entity GUIDs to assign to this ring. Only the entities listed here are managed by this resource; any other entities present in the ring through other means are not affected. Removing a GUID from this list will remove that entity from the fleet ring on the next apply.
    Name string
    The name of the ring (e.g. "default", "canary").
    EntityIds []string
    An ordered list of entity GUIDs to assign to this ring. Only the entities listed here are managed by this resource; any other entities present in the ring through other means are not affected. Removing a GUID from this list will remove that entity from the fleet ring on the next apply.
    Name string
    The name of the ring (e.g. "default", "canary").
    entity_ids list(string)
    An ordered list of entity GUIDs to assign to this ring. Only the entities listed here are managed by this resource; any other entities present in the ring through other means are not affected. Removing a GUID from this list will remove that entity from the fleet ring on the next apply.
    name string
    The name of the ring (e.g. "default", "canary").
    entityIds List<String>
    An ordered list of entity GUIDs to assign to this ring. Only the entities listed here are managed by this resource; any other entities present in the ring through other means are not affected. Removing a GUID from this list will remove that entity from the fleet ring on the next apply.
    name String
    The name of the ring (e.g. "default", "canary").
    entityIds string[]
    An ordered list of entity GUIDs to assign to this ring. Only the entities listed here are managed by this resource; any other entities present in the ring through other means are not affected. Removing a GUID from this list will remove that entity from the fleet ring on the next apply.
    name string
    The name of the ring (e.g. "default", "canary").
    entity_ids Sequence[str]
    An ordered list of entity GUIDs to assign to this ring. Only the entities listed here are managed by this resource; any other entities present in the ring through other means are not affected. Removing a GUID from this list will remove that entity from the fleet ring on the next apply.
    name str
    The name of the ring (e.g. "default", "canary").
    entityIds List<String>
    An ordered list of entity GUIDs to assign to this ring. Only the entities listed here are managed by this resource; any other entities present in the ring through other means are not affected. Removing a GUID from this list will remove that entity from the fleet ring on the next apply.
    name String
    The name of the ring (e.g. "default", "canary").

    Import

    A newrelic.FleetMembers resource can be imported using the fleet GUID:

    $ pulumi import newrelic:index/fleetMembers:FleetMembers example <fleet_guid>

    On import, the resource queries all current members of the fleet and populates a single ring block named "default" with all discovered entity GUIDs. For fleets with entities distributed across multiple rings, update the ring blocks in the configuration to match the actual ring topology after import and run pulumi preview to confirm there are no unintended changes.

    Note on ordering Because entityIds is an ordered list, the entity GUIDs populated on import reflect the order returned by the API. If your configuration specifies a different order, pulumi preview will show an in-place update to reorder the list. Reorder the entityIds entries in your configuration to match the imported order, or apply once to let Terraform reorder the state.

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    New Relic pulumi/pulumi-newrelic
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the newrelic Terraform Provider.
    newrelic logo
    Viewing docs for New Relic v5.69.0
    published on Monday, May 25, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-newrelic

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial