FleetDeployment

New Relic v5.72.2, Jun 23 26

Viewing docs for New Relic v5.72.2
published on Tuesday, Jun 23, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-newrelic

Viewing docs for New Relic v5.72.2
published on Tuesday, Jun 23, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-newrelic

A fleet deployment defines the agent versions and configuration versions to roll out to a fleet. Each deployment belongs to a fleet and may contain zero or more agent blocks describing which agent type and version to deploy and which configuration version (from newrelic.FleetConfiguration) to apply.

Note: Phase-gate immutability. Deployments can only be modified while in the CREATED phase. Once the fleet backend begins executing the deployment (phase advances to IN_PROGRESS, FAILED, or COMPLETED), any attempt to change name, description, agent, or tags is blocked at plan time with a clear error. The recommended recovery path is terraform state rm <resource_address> (or a removed block) to drop the executed deployment from Terraform state, then re-declare a fresh deployment with the desired configuration. terraform destroy works only if you have no pending changes to the deployment in your HCL — otherwise the same plan-time gate fires during the destroy plan.

Example Usage

Basic Deployment

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

const infraCfg = new newrelic.FleetConfiguration("infra_cfg", {
    name: "Production Infra Config",
    agentType: "NRInfra",
    managedEntityType: "HOST",
    operatingSystem: "LINUX",
    configurationContent: `log:
  level: info
`,
});
const infra = new newrelic.FleetDeployment("infra", {
    fleetId: prod.id,
    name: "Production Infra Deployment",
    description: "Deploys NRInfra v1.58.0 with the production config",
    agents: [{
        agentType: "NRInfra",
        version: "1.58.0",
        configurationVersionId: infraCfg.latestVersionEntityId,
    }],
});

import pulumi
import pulumi_newrelic as newrelic

infra_cfg = newrelic.FleetConfiguration("infra_cfg",
    name="Production Infra Config",
    agent_type="NRInfra",
    managed_entity_type="HOST",
    operating_system="LINUX",
    configuration_content="""log:
  level: info
""")
infra = newrelic.FleetDeployment("infra",
    fleet_id=prod["id"],
    name="Production Infra Deployment",
    description="Deploys NRInfra v1.58.0 with the production config",
    agents=[{
        "agent_type": "NRInfra",
        "version": "1.58.0",
        "configuration_version_id": infra_cfg.latest_version_entity_id,
    }])

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 {
		infraCfg, err := newrelic.NewFleetConfiguration(ctx, "infra_cfg", &newrelic.FleetConfigurationArgs{
			Name:                 pulumi.String("Production Infra Config"),
			AgentType:            pulumi.String("NRInfra"),
			ManagedEntityType:    pulumi.String("HOST"),
			OperatingSystem:      pulumi.String("LINUX"),
			ConfigurationContent: pulumi.String("log:\n  level: info\n"),
		})
		if err != nil {
			return err
		}
		_, err = newrelic.NewFleetDeployment(ctx, "infra", &newrelic.FleetDeploymentArgs{
			FleetId:     pulumi.Any(prod.Id),
			Name:        pulumi.String("Production Infra Deployment"),
			Description: pulumi.String("Deploys NRInfra v1.58.0 with the production config"),
			Agents: newrelic.FleetDeploymentAgentArray{
				&newrelic.FleetDeploymentAgentArgs{
					AgentType:              pulumi.String("NRInfra"),
					Version:                pulumi.String("1.58.0"),
					ConfigurationVersionId: infraCfg.LatestVersionEntityId,
				},
			},
		})
		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 infraCfg = new NewRelic.FleetConfiguration("infra_cfg", new()
    {
        Name = "Production Infra Config",
        AgentType = "NRInfra",
        ManagedEntityType = "HOST",
        OperatingSystem = "LINUX",
        ConfigurationContent = @"log:
  level: info
",
    });

    var infra = new NewRelic.FleetDeployment("infra", new()
    {
        FleetId = prod.Id,
        Name = "Production Infra Deployment",
        Description = "Deploys NRInfra v1.58.0 with the production config",
        Agents = new[]
        {
            new NewRelic.Inputs.FleetDeploymentAgentArgs
            {
                AgentType = "NRInfra",
                Version = "1.58.0",
                ConfigurationVersionId = infraCfg.LatestVersionEntityId,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.FleetConfiguration;
import com.pulumi.newrelic.FleetConfigurationArgs;
import com.pulumi.newrelic.FleetDeployment;
import com.pulumi.newrelic.FleetDeploymentArgs;
import com.pulumi.newrelic.inputs.FleetDeploymentAgentArgs;
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 infraCfg = new FleetConfiguration("infraCfg", FleetConfigurationArgs.builder()
            .name("Production Infra Config")
            .agentType("NRInfra")
            .managedEntityType("HOST")
            .operatingSystem("LINUX")
            .configurationContent("""
log:
  level: info
            """)
            .build());

        var infra = new FleetDeployment("infra", FleetDeploymentArgs.builder()
            .fleetId(prod.id())
            .name("Production Infra Deployment")
            .description("Deploys NRInfra v1.58.0 with the production config")
            .agents(FleetDeploymentAgentArgs.builder()
                .agentType("NRInfra")
                .version("1.58.0")
                .configurationVersionId(infraCfg.latestVersionEntityId())
                .build())
            .build());

    }
}

resources:
  infraCfg:
    type: newrelic:FleetConfiguration
    name: infra_cfg
    properties:
      name: Production Infra Config
      agentType: NRInfra
      managedEntityType: HOST
      operatingSystem: LINUX
      configurationContent: |
        log:
          level: info
  infra:
    type: newrelic:FleetDeployment
    properties:
      fleetId: ${prod.id}
      name: Production Infra Deployment
      description: Deploys NRInfra v1.58.0 with the production config
      agents:
        - agentType: NRInfra
          version: 1.58.0
          configurationVersionId: ${infraCfg.latestVersionEntityId}

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

resource "newrelic_fleetconfiguration" "infra_cfg" {
  name                  = "Production Infra Config"
  agent_type            = "NRInfra"
  managed_entity_type   = "HOST"
  operating_system      = "LINUX"
  configuration_content = "log:\n  level: info\n"
}
resource "newrelic_fleetdeployment" "infra" {
  fleet_id    = prod.id
  name        = "Production Infra Deployment"
  description = "Deploys NRInfra v1.58.0 with the production config"
  agents {
    agent_type               = "NRInfra"
    version                  = "1.58.0"
    configuration_version_id = newrelic_fleetconfiguration.infra_cfg.latest_version_entity_id
  }
}

Multiple Agents

Each agentType may appear at most once per deployment.

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

const fullStack = new newrelic.FleetDeployment("full_stack", {
    fleetId: prod.id,
    name: "Full Stack Deployment",
    agents: [
        {
            agentType: "NRInfra",
            version: "1.58.0",
            configurationVersionId: infraCfg.latestVersionEntityId,
        },
        {
            agentType: "FluentBit",
            version: "3.2.0",
            configurationVersionId: fbCfg.latestVersionEntityId,
        },
    ],
});

import pulumi
import pulumi_newrelic as newrelic

full_stack = newrelic.FleetDeployment("full_stack",
    fleet_id=prod["id"],
    name="Full Stack Deployment",
    agents=[
        {
            "agent_type": "NRInfra",
            "version": "1.58.0",
            "configuration_version_id": infra_cfg["latestVersionEntityId"],
        },
        {
            "agent_type": "FluentBit",
            "version": "3.2.0",
            "configuration_version_id": fb_cfg["latestVersionEntityId"],
        },
    ])

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.NewFleetDeployment(ctx, "full_stack", &newrelic.FleetDeploymentArgs{
			FleetId: pulumi.Any(prod.Id),
			Name:    pulumi.String("Full Stack Deployment"),
			Agents: newrelic.FleetDeploymentAgentArray{
				&newrelic.FleetDeploymentAgentArgs{
					AgentType:              pulumi.String("NRInfra"),
					Version:                pulumi.String("1.58.0"),
					ConfigurationVersionId: pulumi.Any(infraCfg.LatestVersionEntityId),
				},
				&newrelic.FleetDeploymentAgentArgs{
					AgentType:              pulumi.String("FluentBit"),
					Version:                pulumi.String("3.2.0"),
					ConfigurationVersionId: pulumi.Any(fbCfg.LatestVersionEntityId),
				},
			},
		})
		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 fullStack = new NewRelic.FleetDeployment("full_stack", new()
    {
        FleetId = prod.Id,
        Name = "Full Stack Deployment",
        Agents = new[]
        {
            new NewRelic.Inputs.FleetDeploymentAgentArgs
            {
                AgentType = "NRInfra",
                Version = "1.58.0",
                ConfigurationVersionId = infraCfg.LatestVersionEntityId,
            },
            new NewRelic.Inputs.FleetDeploymentAgentArgs
            {
                AgentType = "FluentBit",
                Version = "3.2.0",
                ConfigurationVersionId = fbCfg.LatestVersionEntityId,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.FleetDeployment;
import com.pulumi.newrelic.FleetDeploymentArgs;
import com.pulumi.newrelic.inputs.FleetDeploymentAgentArgs;
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 fullStack = new FleetDeployment("fullStack", FleetDeploymentArgs.builder()
            .fleetId(prod.id())
            .name("Full Stack Deployment")
            .agents(            
                FleetDeploymentAgentArgs.builder()
                    .agentType("NRInfra")
                    .version("1.58.0")
                    .configurationVersionId(infraCfg.latestVersionEntityId())
                    .build(),
                FleetDeploymentAgentArgs.builder()
                    .agentType("FluentBit")
                    .version("3.2.0")
                    .configurationVersionId(fbCfg.latestVersionEntityId())
                    .build())
            .build());

    }
}

resources:
  fullStack:
    type: newrelic:FleetDeployment
    name: full_stack
    properties:
      fleetId: ${prod.id}
      name: Full Stack Deployment
      agents:
        - agentType: NRInfra
          version: 1.58.0
          configurationVersionId: ${infraCfg.latestVersionEntityId}
        - agentType: FluentBit
          version: 3.2.0
          configurationVersionId: ${fbCfg.latestVersionEntityId}

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

resource "newrelic_fleetdeployment" "full_stack" {
  fleet_id = prod.id
  name     = "Full Stack Deployment"
  agents {
    agent_type               = "NRInfra"
    version                  = "1.58.0"
    configuration_version_id = infraCfg.latestVersionEntityId
  }
  agents {
    agent_type               = "FluentBit"
    version                  = "3.2.0"
    configuration_version_id = fbCfg.latestVersionEntityId
  }
}

Zero-Agent Deployment

A deployment can be created or updated with zero agent blocks — for example, to drain all agent assignments from an existing deployment, or to seed a deployment record that will have agents added later (while still in CREATED phase).

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

const drained = new newrelic.FleetDeployment("drained", {
    fleetId: prod.id,
    name: "Drained deployment",
});

import pulumi
import pulumi_newrelic as newrelic

drained = newrelic.FleetDeployment("drained",
    fleet_id=prod["id"],
    name="Drained deployment")

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.NewFleetDeployment(ctx, "drained", &newrelic.FleetDeploymentArgs{
			FleetId: pulumi.Any(prod.Id),
			Name:    pulumi.String("Drained deployment"),
		})
		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 drained = new NewRelic.FleetDeployment("drained", new()
    {
        FleetId = prod.Id,
        Name = "Drained deployment",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.FleetDeployment;
import com.pulumi.newrelic.FleetDeploymentArgs;
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 drained = new FleetDeployment("drained", FleetDeploymentArgs.builder()
            .fleetId(prod.id())
            .name("Drained deployment")
            .build());

    }
}

resources:
  drained:
    type: newrelic:FleetDeployment
    properties:
      fleetId: ${prod.id}
      name: Drained deployment

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

resource "newrelic_fleetdeployment" "drained" {
  fleet_id = prod.id
  name     = "Drained deployment"
}

Pinning to a Specific Configuration Version

By default, referencing newrelic_fleet_configuration.<name>.latest_version_entity_id ties the deployment to whichever version is current at plan time. Updating the configuration’s configurationContent will change latestVersionEntityId, which in turn proposes an update to any deployment referencing it. If the deployment has already left CREATED, that update will be blocked by the phase-gate — see the note above.

For long-lived deployments that should remain stable, pin to a specific historical version instead:

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

const pinned = new newrelic.FleetDeployment("pinned", {
    fleetId: prod.id,
    name: "Stable v1 rollout",
    agents: [{
        agentType: "NRInfra",
        version: "1.58.0",
        configurationVersionId: infraCfg.versionEntityIds[0],
    }],
});

import pulumi
import pulumi_newrelic as newrelic

pinned = newrelic.FleetDeployment("pinned",
    fleet_id=prod["id"],
    name="Stable v1 rollout",
    agents=[{
        "agent_type": "NRInfra",
        "version": "1.58.0",
        "configuration_version_id": infra_cfg["versionEntityIds"][0],
    }])

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.NewFleetDeployment(ctx, "pinned", &newrelic.FleetDeploymentArgs{
			FleetId: pulumi.Any(prod.Id),
			Name:    pulumi.String("Stable v1 rollout"),
			Agents: newrelic.FleetDeploymentAgentArray{
				&newrelic.FleetDeploymentAgentArgs{
					AgentType:              pulumi.String("NRInfra"),
					Version:                pulumi.String("1.58.0"),
					ConfigurationVersionId: pulumi.Any(infraCfg.VersionEntityIds[0]),
				},
			},
		})
		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 pinned = new NewRelic.FleetDeployment("pinned", new()
    {
        FleetId = prod.Id,
        Name = "Stable v1 rollout",
        Agents = new[]
        {
            new NewRelic.Inputs.FleetDeploymentAgentArgs
            {
                AgentType = "NRInfra",
                Version = "1.58.0",
                ConfigurationVersionId = infraCfg.VersionEntityIds[0],
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.FleetDeployment;
import com.pulumi.newrelic.FleetDeploymentArgs;
import com.pulumi.newrelic.inputs.FleetDeploymentAgentArgs;
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 pinned = new FleetDeployment("pinned", FleetDeploymentArgs.builder()
            .fleetId(prod.id())
            .name("Stable v1 rollout")
            .agents(FleetDeploymentAgentArgs.builder()
                .agentType("NRInfra")
                .version("1.58.0")
                .configurationVersionId(infraCfg.versionEntityIds()[0])
                .build())
            .build());

    }
}

resources:
  pinned:
    type: newrelic:FleetDeployment
    properties:
      fleetId: ${prod.id}
      name: Stable v1 rollout
      agents:
        - agentType: NRInfra
          version: 1.58.0
          configurationVersionId: ${infraCfg.versionEntityIds[0]}

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

resource "newrelic_fleetdeployment" "pinned" {
  fleet_id = prod.id
  name     = "Stable v1 rollout"
  agents {
    agent_type               = "NRInfra"
    version                  = "1.58.0"
    configuration_version_id = infraCfg.versionEntityIds[0]
  }
}

With Tags

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

const infra = new newrelic.FleetDeployment("infra", {
    fleetId: prod.id,
    name: "Production Deployment",
    agents: [{
        agentType: "NRInfra",
        version: "1.58.0",
        configurationVersionId: infraCfg.latestVersionEntityId,
    }],
    tags: [
        "environment:production",
        "team:platform",
    ],
});

import pulumi
import pulumi_newrelic as newrelic

infra = newrelic.FleetDeployment("infra",
    fleet_id=prod["id"],
    name="Production Deployment",
    agents=[{
        "agent_type": "NRInfra",
        "version": "1.58.0",
        "configuration_version_id": infra_cfg["latestVersionEntityId"],
    }],
    tags=[
        "environment:production",
        "team:platform",
    ])

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.NewFleetDeployment(ctx, "infra", &newrelic.FleetDeploymentArgs{
			FleetId: pulumi.Any(prod.Id),
			Name:    pulumi.String("Production Deployment"),
			Agents: newrelic.FleetDeploymentAgentArray{
				&newrelic.FleetDeploymentAgentArgs{
					AgentType:              pulumi.String("NRInfra"),
					Version:                pulumi.String("1.58.0"),
					ConfigurationVersionId: pulumi.Any(infraCfg.LatestVersionEntityId),
				},
			},
			Tags: pulumi.StringArray{
				pulumi.String("environment:production"),
				pulumi.String("team:platform"),
			},
		})
		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 infra = new NewRelic.FleetDeployment("infra", new()
    {
        FleetId = prod.Id,
        Name = "Production Deployment",
        Agents = new[]
        {
            new NewRelic.Inputs.FleetDeploymentAgentArgs
            {
                AgentType = "NRInfra",
                Version = "1.58.0",
                ConfigurationVersionId = infraCfg.LatestVersionEntityId,
            },
        },
        Tags = new[]
        {
            "environment:production",
            "team:platform",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.FleetDeployment;
import com.pulumi.newrelic.FleetDeploymentArgs;
import com.pulumi.newrelic.inputs.FleetDeploymentAgentArgs;
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 infra = new FleetDeployment("infra", FleetDeploymentArgs.builder()
            .fleetId(prod.id())
            .name("Production Deployment")
            .agents(FleetDeploymentAgentArgs.builder()
                .agentType("NRInfra")
                .version("1.58.0")
                .configurationVersionId(infraCfg.latestVersionEntityId())
                .build())
            .tags(            
                "environment:production",
                "team:platform")
            .build());

    }
}

resources:
  infra:
    type: newrelic:FleetDeployment
    properties:
      fleetId: ${prod.id}
      name: Production Deployment
      agents:
        - agentType: NRInfra
          version: 1.58.0
          configurationVersionId: ${infraCfg.latestVersionEntityId}
      tags:
        - environment:production
        - team:platform

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

resource "newrelic_fleetdeployment" "infra" {
  fleet_id = prod.id
  name     = "Production Deployment"
  agents {
    agent_type               = "NRInfra"
    version                  = "1.58.0"
    configuration_version_id = infraCfg.latestVersionEntityId
  }
  tags = ["environment:production", "team:platform"]
}

Create FleetDeployment Resource

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

Constructor syntax

new FleetDeployment(name: string, args: FleetDeploymentArgs, opts?: CustomResourceOptions);

@overload
def FleetDeployment(resource_name: str,
                    args: FleetDeploymentArgs,
                    opts: Optional[ResourceOptions] = None)

@overload
def FleetDeployment(resource_name: str,
                    opts: Optional[ResourceOptions] = None,
                    fleet_id: Optional[str] = None,
                    agents: Optional[Sequence[FleetDeploymentAgentArgs]] = None,
                    description: Optional[str] = None,
                    name: Optional[str] = None,
                    organization_id: Optional[str] = None,
                    tags: Optional[Sequence[str]] = None)

func NewFleetDeployment(ctx *Context, name string, args FleetDeploymentArgs, opts ...ResourceOption) (*FleetDeployment, error)

public FleetDeployment(string name, FleetDeploymentArgs args, CustomResourceOptions? opts = null)

public FleetDeployment(String name, FleetDeploymentArgs args)
public FleetDeployment(String name, FleetDeploymentArgs args, CustomResourceOptions options)

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

resource "newrelic_fleetdeployment" "name" {
    # resource properties
}

Parameters

name string: The unique name of the resource.
args FleetDeploymentArgs: 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 FleetDeploymentArgs: 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 FleetDeploymentArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args FleetDeploymentArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args FleetDeploymentArgs: 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 fleetDeploymentResource = new NewRelic.FleetDeployment("fleetDeploymentResource", new()
{
    FleetId = "string",
    Agents = new[]
    {
        new NewRelic.Inputs.FleetDeploymentAgentArgs
        {
            AgentType = "string",
            ConfigurationVersionId = "string",
            Version = "string",
        },
    },
    Description = "string",
    Name = "string",
    OrganizationId = "string",
    Tags = new[]
    {
        "string",
    },
});

example, err := newrelic.NewFleetDeployment(ctx, "fleetDeploymentResource", &newrelic.FleetDeploymentArgs{
	FleetId: pulumi.String("string"),
	Agents: newrelic.FleetDeploymentAgentArray{
		&newrelic.FleetDeploymentAgentArgs{
			AgentType:              pulumi.String("string"),
			ConfigurationVersionId: pulumi.String("string"),
			Version:                pulumi.String("string"),
		},
	},
	Description:    pulumi.String("string"),
	Name:           pulumi.String("string"),
	OrganizationId: pulumi.String("string"),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
})

resource "newrelic_fleetdeployment" "fleetDeploymentResource" {
  fleet_id = "string"
  agents {
    agent_type               = "string"
    configuration_version_id = "string"
    version                  = "string"
  }
  description     = "string"
  name            = "string"
  organization_id = "string"
  tags            = ["string"]
}

var fleetDeploymentResource = new FleetDeployment("fleetDeploymentResource", FleetDeploymentArgs.builder()
    .fleetId("string")
    .agents(FleetDeploymentAgentArgs.builder()
        .agentType("string")
        .configurationVersionId("string")
        .version("string")
        .build())
    .description("string")
    .name("string")
    .organizationId("string")
    .tags("string")
    .build());

fleet_deployment_resource = newrelic.FleetDeployment("fleetDeploymentResource",
    fleet_id="string",
    agents=[{
        "agent_type": "string",
        "configuration_version_id": "string",
        "version": "string",
    }],
    description="string",
    name="string",
    organization_id="string",
    tags=["string"])

const fleetDeploymentResource = new newrelic.FleetDeployment("fleetDeploymentResource", {
    fleetId: "string",
    agents: [{
        agentType: "string",
        configurationVersionId: "string",
        version: "string",
    }],
    description: "string",
    name: "string",
    organizationId: "string",
    tags: ["string"],
});

type: newrelic:FleetDeployment
properties:
    agents:
        - agentType: string
          configurationVersionId: string
          version: string
    description: string
    fleetId: string
    name: string
    organizationId: string
    tags:
        - string