1. Packages
  2. Equinix
  3. API Docs
  4. metal
  5. getPlans
Equinix v0.10.0 published on Wednesday, May 22, 2024 by Equinix

equinix.metal.getPlans

Explore with Pulumi AI

equinix logo
Equinix v0.10.0 published on Wednesday, May 22, 2024 by Equinix

    Provides an Equinix Metal plans datasource. This can be used to find plans that meet a filter criteria.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as equinix from "@pulumi/equinix";
    
    const example = equinix.metal.getPlans({
        sorts: [{
            attribute: "pricing_hour",
            direction: "asc",
        }],
        filters: [
            {
                attribute: "pricing_hour",
                values: ["2.5"],
                matchBy: "less_than",
            },
            {
                attribute: "available_in_metros",
                values: [
                    "da",
                    "sv",
                ],
            },
        ],
    });
    export const plans = example.then(example => example.plans);
    
    import pulumi
    import pulumi_equinix as equinix
    
    example = equinix.metal.get_plans(sorts=[equinix.metal.GetPlansSortArgs(
            attribute="pricing_hour",
            direction="asc",
        )],
        filters=[
            equinix.metal.GetPlansFilterArgs(
                attribute="pricing_hour",
                values=["2.5"],
                match_by="less_than",
            ),
            equinix.metal.GetPlansFilterArgs(
                attribute="available_in_metros",
                values=[
                    "da",
                    "sv",
                ],
            ),
        ])
    pulumi.export("plans", example.plans)
    
    package main
    
    import (
    	"github.com/equinix/pulumi-equinix/sdk/go/equinix/metal"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		example, err := metal.GetPlans(ctx, &metal.GetPlansArgs{
    			Sorts: []metal.GetPlansSort{
    				{
    					Attribute: "pricing_hour",
    					Direction: pulumi.StringRef("asc"),
    				},
    			},
    			Filters: []metal.GetPlansFilter{
    				{
    					Attribute: "pricing_hour",
    					Values: []string{
    						"2.5",
    					},
    					MatchBy: pulumi.StringRef("less_than"),
    				},
    				{
    					Attribute: "available_in_metros",
    					Values: []string{
    						"da",
    						"sv",
    					},
    				},
    			},
    		}, nil)
    		if err != nil {
    			return err
    		}
    		ctx.Export("plans", example.Plans)
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Equinix = Pulumi.Equinix;
    
    return await Deployment.RunAsync(() => 
    {
        var example = Equinix.Metal.GetPlans.Invoke(new()
        {
            Sorts = new[]
            {
                new Equinix.Metal.Inputs.GetPlansSortInputArgs
                {
                    Attribute = "pricing_hour",
                    Direction = "asc",
                },
            },
            Filters = new[]
            {
                new Equinix.Metal.Inputs.GetPlansFilterInputArgs
                {
                    Attribute = "pricing_hour",
                    Values = new[]
                    {
                        "2.5",
                    },
                    MatchBy = "less_than",
                },
                new Equinix.Metal.Inputs.GetPlansFilterInputArgs
                {
                    Attribute = "available_in_metros",
                    Values = new[]
                    {
                        "da",
                        "sv",
                    },
                },
            },
        });
    
        return new Dictionary<string, object?>
        {
            ["plans"] = example.Apply(getPlansResult => getPlansResult.Plans),
        };
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.equinix.metal.MetalFunctions;
    import com.pulumi.equinix.metal.inputs.GetPlansArgs;
    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) {
            final var example = MetalFunctions.getPlans(GetPlansArgs.builder()
                .sorts(GetPlansSortArgs.builder()
                    .attribute("pricing_hour")
                    .direction("asc")
                    .build())
                .filters(            
                    GetPlansFilterArgs.builder()
                        .attribute("pricing_hour")
                        .values(2.5)
                        .matchBy("less_than")
                        .build(),
                    GetPlansFilterArgs.builder()
                        .attribute("available_in_metros")
                        .values(                    
                            "da",
                            "sv")
                        .build())
                .build());
    
            ctx.export("plans", example.applyValue(getPlansResult -> getPlansResult.plans()));
        }
    }
    
    variables:
      example:
        fn::invoke:
          Function: equinix:metal:getPlans
          Arguments:
            sorts:
              - attribute: pricing_hour
                direction: asc
            filters:
              - attribute: pricing_hour
                values:
                  - 2.5
                matchBy: less_than
              - attribute: available_in_metros
                values:
                  - da
                  - sv
    outputs:
      plans: ${example.plans}
    
    import * as pulumi from "@pulumi/pulumi";
    import * as equinix from "@pulumi/equinix";
    
    const example = equinix.metal.getPlans({
        filters: [
            {
                attribute: "class",
                values: ["large"],
                matchBy: "substring",
            },
            {
                attribute: "deployment_types",
                values: ["spot_market"],
            },
            {
                attribute: "available_in_metros",
                values: [
                    "da",
                    "sv",
                ],
                all: true,
            },
        ],
    });
    export const plans = example.then(example => example.plans);
    
    import pulumi
    import pulumi_equinix as equinix
    
    example = equinix.metal.get_plans(filters=[
        equinix.metal.GetPlansFilterArgs(
            attribute="class",
            values=["large"],
            match_by="substring",
        ),
        equinix.metal.GetPlansFilterArgs(
            attribute="deployment_types",
            values=["spot_market"],
        ),
        equinix.metal.GetPlansFilterArgs(
            attribute="available_in_metros",
            values=[
                "da",
                "sv",
            ],
            all=True,
        ),
    ])
    pulumi.export("plans", example.plans)
    
    package main
    
    import (
    	"github.com/equinix/pulumi-equinix/sdk/go/equinix/metal"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		example, err := metal.GetPlans(ctx, &metal.GetPlansArgs{
    			Filters: pulumi.Array{
    				metal.GetPlansFilter{
    					Attribute: "class",
    					Values: []string{
    						"large",
    					},
    					MatchBy: pulumi.StringRef("substring"),
    				},
    				metal.GetPlansFilter{
    					Attribute: "deployment_types",
    					Values: []string{
    						"spot_market",
    					},
    				},
    				metal.GetPlansFilter{
    					Attribute: "available_in_metros",
    					Values: []string{
    						"da",
    						"sv",
    					},
    					All: pulumi.BoolRef(true),
    				},
    			},
    		}, nil)
    		if err != nil {
    			return err
    		}
    		ctx.Export("plans", example.Plans)
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Equinix = Pulumi.Equinix;
    
    return await Deployment.RunAsync(() => 
    {
        var example = Equinix.Metal.GetPlans.Invoke(new()
        {
            Filters = new[]
            {
                new Equinix.Metal.Inputs.GetPlansFilterInputArgs
                {
                    Attribute = "class",
                    Values = new[]
                    {
                        "large",
                    },
                    MatchBy = "substring",
                },
                new Equinix.Metal.Inputs.GetPlansFilterInputArgs
                {
                    Attribute = "deployment_types",
                    Values = new[]
                    {
                        "spot_market",
                    },
                },
                new Equinix.Metal.Inputs.GetPlansFilterInputArgs
                {
                    Attribute = "available_in_metros",
                    Values = new[]
                    {
                        "da",
                        "sv",
                    },
                    All = true,
                },
            },
        });
    
        return new Dictionary<string, object?>
        {
            ["plans"] = example.Apply(getPlansResult => getPlansResult.Plans),
        };
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.equinix.metal.MetalFunctions;
    import com.pulumi.equinix.metal.inputs.GetPlansArgs;
    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) {
            final var example = MetalFunctions.getPlans(GetPlansArgs.builder()
                .filters(            
                    GetPlansFilterArgs.builder()
                        .attribute("class")
                        .values("large")
                        .matchBy("substring")
                        .build(),
                    GetPlansFilterArgs.builder()
                        .attribute("deployment_types")
                        .values("spot_market")
                        .build(),
                    GetPlansFilterArgs.builder()
                        .attribute("available_in_metros")
                        .values(                    
                            "da",
                            "sv")
                        .all(true)
                        .build())
                .build());
    
            ctx.export("plans", example.applyValue(getPlansResult -> getPlansResult.plans()));
        }
    }
    
    variables:
      example:
        fn::invoke:
          Function: equinix:metal:getPlans
          Arguments:
            filters:
              - attribute: class
                values:
                  - large
                matchBy: substring
              - attribute: deployment_types
                values:
                  - spot_market
              - attribute: available_in_metros
                values:
                  - da
                  - sv
                all: true
    outputs:
      plans: ${example.plans}
    

    Ignoring Changes to Plans/Metro

    Preserve deployed device plan, facility and metro when creating a new execution plan.

    As described in the data-resource-behavior feature as shown in the example below.

    import * as pulumi from "@pulumi/pulumi";
    import * as equinix from "@equinix-labs/pulumi-equinix";
    import * as equinix from "@pulumi/equinix";
    
    const examplePlans = equinix.metal.getPlans({
        sorts: [{
            attribute: "pricing_hour",
            direction: "asc",
        }],
        filters: [
            {
                attribute: "name",
                values: [
                    "c3.small.x86",
                    "c3.medium.x86",
                    "m3.large.x86",
                ],
            },
            {
                attribute: "available_in_metros",
                values: ["sv"],
            },
        ],
    });
    // This equinix_metal_device will use the first returned plan and the first metro in which that plan is available
    // It will ignore future changes on plan and metro
    const exampleDevice = new equinix.metal.Device("exampleDevice", {
        hostname: "example",
        plan: examplePlans.then(examplePlans => examplePlans.plans?.[0]?.name).apply((x) => equinix.metal.Plan[x]),
        metro: examplePlans.then(examplePlans => examplePlans.plans?.[0]?.availableInMetros?.[0]),
        operatingSystem: equinix.metal.OperatingSystem.Ubuntu20_04,
        billingCycle: equinix.metal.BillingCycle.Hourly,
        projectId: _var.project_id,
    });
    
    import pulumi
    import pulumi_equinix as equinix
    
    example_plans = equinix.metal.get_plans(sorts=[equinix.metal.GetPlansSortArgs(
            attribute="pricing_hour",
            direction="asc",
        )],
        filters=[
            equinix.metal.GetPlansFilterArgs(
                attribute="name",
                values=[
                    "c3.small.x86",
                    "c3.medium.x86",
                    "m3.large.x86",
                ],
            ),
            equinix.metal.GetPlansFilterArgs(
                attribute="available_in_metros",
                values=["sv"],
            ),
        ])
    # This equinix_metal_device will use the first returned plan and the first metro in which that plan is available
    # It will ignore future changes on plan and metro
    example_device = equinix.metal.Device("exampleDevice",
        hostname="example",
        plan=example_plans.plans[0].name.apply(lambda x: equinix.metal.Plan(x)),
        metro=example_plans.plans[0].available_in_metros[0],
        operating_system=equinix.metal.OperatingSystem.UBUNTU20_04,
        billing_cycle=equinix.metal.BillingCycle.HOURLY,
        project_id=var["project_id"])
    
    package main
    
    import (
    	"github.com/equinix/pulumi-equinix/sdk/go/equinix/metal"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		examplePlans, err := metal.GetPlans(ctx, &metal.GetPlansArgs{
    			Sorts: []metal.GetPlansSort{
    				{
    					Attribute: "pricing_hour",
    					Direction: pulumi.StringRef("asc"),
    				},
    			},
    			Filters: []metal.GetPlansFilter{
    				{
    					Attribute: "name",
    					Values: []string{
    						"c3.small.x86",
    						"c3.medium.x86",
    						"m3.large.x86",
    					},
    				},
    				{
    					Attribute: "available_in_metros",
    					Values: []string{
    						"sv",
    					},
    				},
    			},
    		}, nil)
    		if err != nil {
    			return err
    		}
    		// This equinix_metal_device will use the first returned plan and the first metro in which that plan is available
    		// It will ignore future changes on plan and metro
    		_, err = metal.NewDevice(ctx, "exampleDevice", &metal.DeviceArgs{
    			Hostname:        pulumi.String("example"),
    			Plan:            examplePlans.Plans[0].Name.ApplyT(func(x *string) metal.Plan { return metal.Plan(*x) }).(metal.PlanOutput),
    			Metro:           pulumi.String(examplePlans.Plans[0].AvailableInMetros[0]),
    			OperatingSystem: pulumi.String(metal.OperatingSystem_Ubuntu20_04),
    			BillingCycle:    pulumi.String(metal.BillingCycleHourly),
    			ProjectId:       pulumi.Any(_var.Project_id),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Equinix = Pulumi.Equinix;
    
    return await Deployment.RunAsync(() => 
    {
        var examplePlans = Equinix.Metal.GetPlans.Invoke(new()
        {
            Sorts = new[]
            {
                new Equinix.Metal.Inputs.GetPlansSortInputArgs
                {
                    Attribute = "pricing_hour",
                    Direction = "asc",
                },
            },
            Filters = new[]
            {
                new Equinix.Metal.Inputs.GetPlansFilterInputArgs
                {
                    Attribute = "name",
                    Values = new[]
                    {
                        "c3.small.x86",
                        "c3.medium.x86",
                        "m3.large.x86",
                    },
                },
                new Equinix.Metal.Inputs.GetPlansFilterInputArgs
                {
                    Attribute = "available_in_metros",
                    Values = new[]
                    {
                        "sv",
                    },
                },
            },
        });
    
        // This equinix_metal_device will use the first returned plan and the first metro in which that plan is available
        // It will ignore future changes on plan and metro
        var exampleDevice = new Equinix.Metal.Device("exampleDevice", new()
        {
            Hostname = "example",
            Plan = examplePlans.Apply(getPlansResult => getPlansResult.Plans[0]?.Name).Apply(System.Enum.Parse<Equinix.Metal.Plan>),
            Metro = examplePlans.Apply(getPlansResult => getPlansResult.Plans[0]?.AvailableInMetros[0]),
            OperatingSystem = Equinix.Metal.OperatingSystem.Ubuntu20_04,
            BillingCycle = Equinix.Metal.BillingCycle.Hourly,
            ProjectId = @var.Project_id,
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.equinix.metal.MetalFunctions;
    import com.pulumi.equinix.metal.inputs.GetPlansArgs;
    import com.pulumi.equinix.metal.Device;
    import com.pulumi.equinix.metal.DeviceArgs;
    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) {
            final var examplePlans = MetalFunctions.getPlans(GetPlansArgs.builder()
                .sorts(GetPlansSortArgs.builder()
                    .attribute("pricing_hour")
                    .direction("asc")
                    .build())
                .filters(            
                    GetPlansFilterArgs.builder()
                        .attribute("name")
                        .values(                    
                            "c3.small.x86",
                            "c3.medium.x86",
                            "m3.large.x86")
                        .build(),
                    GetPlansFilterArgs.builder()
                        .attribute("available_in_metros")
                        .values("sv")
                        .build())
                .build());
    
            // This equinix_metal_device will use the first returned plan and the first metro in which that plan is available
            // It will ignore future changes on plan and metro
            var exampleDevice = new Device("exampleDevice", DeviceArgs.builder()        
                .hostname("example")
                .plan(examplePlans.applyValue(getPlansResult -> getPlansResult.plans()[0].name()))
                .metro(examplePlans.applyValue(getPlansResult -> getPlansResult.plans()[0].availableInMetros()[0]))
                .operatingSystem("ubuntu_20_04")
                .billingCycle("hourly")
                .projectId(var_.project_id())
                .build());
    
        }
    }
    
    resources:
      # This equinix_metal_device will use the first returned plan and the first metro in which that plan is available
      # It will ignore future changes on plan and metro
      exampleDevice:
        type: equinix:metal:Device
        properties:
          hostname: example
          plan: ${examplePlans.plans[0].name}
          metro: ${examplePlans.plans[0].availableInMetros[0]}
          operatingSystem: ubuntu_20_04
          billingCycle: hourly
          projectId: ${var.project_id}
    variables:
      examplePlans:
        fn::invoke:
          Function: equinix:metal:getPlans
          Arguments:
            sorts:
              - attribute: pricing_hour
                direction: asc
            filters:
              - attribute: name
                values:
                  - c3.small.x86
                  - c3.medium.x86
                  - m3.large.x86
              - attribute: available_in_metros
                values:
                  - sv
    

    If your use case requires dynamic changes of a device plan or metro you can define the lifecycle with a condition.

    import * as pulumi from "@pulumi/pulumi";
    import * as equinix from "@equinix-labs/pulumi-equinix";
    import * as equinix from "@pulumi/equinix";
    
    const config = new pulumi.Config();
    const ignorePlansMetrosChanges = config.getBoolean("ignorePlansMetrosChanges") || false;
    const examplePlans = equinix.metal.getPlans({});
    // required device arguments
    const exampleDevice = new equinix.metal.Device("exampleDevice", {});
    
    import pulumi
    import pulumi_equinix as equinix
    
    config = pulumi.Config()
    ignore_plans_metros_changes = config.get_bool("ignorePlansMetrosChanges")
    if ignore_plans_metros_changes is None:
        ignore_plans_metros_changes = False
    example_plans = equinix.metal.get_plans()
    # required device arguments
    example_device = equinix.metal.Device("exampleDevice")
    
    package main
    
    import (
    	"github.com/equinix/pulumi-equinix/sdk/go/equinix/metal"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		cfg := config.New(ctx, "")
    		ignorePlansMetrosChanges := false
    		if param := cfg.GetBool("ignorePlansMetrosChanges"); param {
    			ignorePlansMetrosChanges = param
    		}
    		_, err := metal.GetPlans(ctx, nil, nil)
    		if err != nil {
    			return err
    		}
    		// required device arguments
    		_, err = metal.NewDevice(ctx, "exampleDevice", nil)
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Equinix = Pulumi.Equinix;
    
    return await Deployment.RunAsync(() => 
    {
        var config = new Config();
        var ignorePlansMetrosChanges = config.GetBoolean("ignorePlansMetrosChanges") ?? false;
        var examplePlans = Equinix.Metal.GetPlans.Invoke();
    
        // required device arguments
        var exampleDevice = new Equinix.Metal.Device("exampleDevice");
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.equinix.metal.MetalFunctions;
    import com.pulumi.equinix.metal.inputs.GetPlansArgs;
    import com.pulumi.equinix.metal.Device;
    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) {
            final var config = ctx.config();
            final var ignorePlansMetrosChanges = config.get("ignorePlansMetrosChanges").orElse(false);
            final var examplePlans = MetalFunctions.getPlans();
    
            // required device arguments
            var exampleDevice = new Device("exampleDevice");
    
        }
    }
    
    configuration:
      # Following example uses a boolean variable that may eventually be set to you false when you update your equinix_metal_plans filter criteria because you need a device plan with a new feature.
      ignorePlansMetrosChanges:
        type: bool
        default: false
    resources:
      exampleDevice:
        type: equinix:metal:Device
    variables:
      examplePlans:
        fn::invoke:
          Function: equinix:metal:getPlans
          Arguments: {}
    

    Using getPlans

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function getPlans(args: GetPlansArgs, opts?: InvokeOptions): Promise<GetPlansResult>
    function getPlansOutput(args: GetPlansOutputArgs, opts?: InvokeOptions): Output<GetPlansResult>
    def get_plans(filters: Optional[Sequence[GetPlansFilter]] = None,
                  sorts: Optional[Sequence[GetPlansSort]] = None,
                  opts: Optional[InvokeOptions] = None) -> GetPlansResult
    def get_plans_output(filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetPlansFilterArgs]]]] = None,
                  sorts: Optional[pulumi.Input[Sequence[pulumi.Input[GetPlansSortArgs]]]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetPlansResult]
    func GetPlans(ctx *Context, args *GetPlansArgs, opts ...InvokeOption) (*GetPlansResult, error)
    func GetPlansOutput(ctx *Context, args *GetPlansOutputArgs, opts ...InvokeOption) GetPlansResultOutput

    > Note: This function is named GetPlans in the Go SDK.

    public static class GetPlans 
    {
        public static Task<GetPlansResult> InvokeAsync(GetPlansArgs args, InvokeOptions? opts = null)
        public static Output<GetPlansResult> Invoke(GetPlansInvokeArgs args, InvokeOptions? opts = null)
    }
    public static CompletableFuture<GetPlansResult> getPlans(GetPlansArgs args, InvokeOptions options)
    // Output-based functions aren't available in Java yet
    
    fn::invoke:
      function: equinix:metal/getPlans:getPlans
      arguments:
        # arguments dictionary

    The following arguments are supported:

    Filters List<GetPlansFilter>
    One or more attribute/values pairs to filter off of
    Sorts List<GetPlansSort>
    One or more attribute/direction pairs on which to sort results. If multiple sorts are provided, they will be applied in order
    Filters []GetPlansFilter
    One or more attribute/values pairs to filter off of
    Sorts []GetPlansSort
    One or more attribute/direction pairs on which to sort results. If multiple sorts are provided, they will be applied in order
    filters List<GetPlansFilter>
    One or more attribute/values pairs to filter off of
    sorts List<GetPlansSort>
    One or more attribute/direction pairs on which to sort results. If multiple sorts are provided, they will be applied in order
    filters GetPlansFilter[]
    One or more attribute/values pairs to filter off of
    sorts GetPlansSort[]
    One or more attribute/direction pairs on which to sort results. If multiple sorts are provided, they will be applied in order
    filters Sequence[GetPlansFilter]
    One or more attribute/values pairs to filter off of
    sorts Sequence[GetPlansSort]
    One or more attribute/direction pairs on which to sort results. If multiple sorts are provided, they will be applied in order
    filters List<Property Map>
    One or more attribute/values pairs to filter off of
    sorts List<Property Map>
    One or more attribute/direction pairs on which to sort results. If multiple sorts are provided, they will be applied in order

    getPlans Result

    The following output properties are available:

    Id string
    The provider-assigned unique ID for this managed resource.
    Plans List<GetPlansPlan>
    Filters List<GetPlansFilter>
    Sorts List<GetPlansSort>
    Id string
    The provider-assigned unique ID for this managed resource.
    Plans []GetPlansPlan
    Filters []GetPlansFilter
    Sorts []GetPlansSort
    id String
    The provider-assigned unique ID for this managed resource.
    plans List<GetPlansPlan>
    filters List<GetPlansFilter>
    sorts List<GetPlansSort>
    id string
    The provider-assigned unique ID for this managed resource.
    plans GetPlansPlan[]
    filters GetPlansFilter[]
    sorts GetPlansSort[]
    id str
    The provider-assigned unique ID for this managed resource.
    plans Sequence[GetPlansPlan]
    filters Sequence[GetPlansFilter]
    sorts Sequence[GetPlansSort]
    id String
    The provider-assigned unique ID for this managed resource.
    plans List<Property Map>
    filters List<Property Map>
    sorts List<Property Map>

    Supporting Types

    GetPlansFilter

    Attribute string
    The attribute used to filter. Filter attributes are case-sensitive
    Values List<string>
    The filter values. Filter values are case-sensitive. If you specify multiple values for a filter, the values are joined with an OR by default, and the request returns all results that match any of the specified values
    All bool

    If is set to true, the values are joined with an AND, and the requests returns only the results that match all specified values. Default is false.

    All fields in the plans block defined below can be used as attribute for both sort and filter blocks.

    MatchBy string
    The type of comparison to apply. One of: in , re, substring, less_than, less_than_or_equal, greater_than, greater_than_or_equal. Default is in.
    Attribute string
    The attribute used to filter. Filter attributes are case-sensitive
    Values []string
    The filter values. Filter values are case-sensitive. If you specify multiple values for a filter, the values are joined with an OR by default, and the request returns all results that match any of the specified values
    All bool

    If is set to true, the values are joined with an AND, and the requests returns only the results that match all specified values. Default is false.

    All fields in the plans block defined below can be used as attribute for both sort and filter blocks.

    MatchBy string
    The type of comparison to apply. One of: in , re, substring, less_than, less_than_or_equal, greater_than, greater_than_or_equal. Default is in.
    attribute String
    The attribute used to filter. Filter attributes are case-sensitive
    values List<String>
    The filter values. Filter values are case-sensitive. If you specify multiple values for a filter, the values are joined with an OR by default, and the request returns all results that match any of the specified values
    all Boolean

    If is set to true, the values are joined with an AND, and the requests returns only the results that match all specified values. Default is false.

    All fields in the plans block defined below can be used as attribute for both sort and filter blocks.

    matchBy String
    The type of comparison to apply. One of: in , re, substring, less_than, less_than_or_equal, greater_than, greater_than_or_equal. Default is in.
    attribute string
    The attribute used to filter. Filter attributes are case-sensitive
    values string[]
    The filter values. Filter values are case-sensitive. If you specify multiple values for a filter, the values are joined with an OR by default, and the request returns all results that match any of the specified values
    all boolean

    If is set to true, the values are joined with an AND, and the requests returns only the results that match all specified values. Default is false.

    All fields in the plans block defined below can be used as attribute for both sort and filter blocks.

    matchBy string
    The type of comparison to apply. One of: in , re, substring, less_than, less_than_or_equal, greater_than, greater_than_or_equal. Default is in.
    attribute str
    The attribute used to filter. Filter attributes are case-sensitive
    values Sequence[str]
    The filter values. Filter values are case-sensitive. If you specify multiple values for a filter, the values are joined with an OR by default, and the request returns all results that match any of the specified values
    all bool

    If is set to true, the values are joined with an AND, and the requests returns only the results that match all specified values. Default is false.

    All fields in the plans block defined below can be used as attribute for both sort and filter blocks.

    match_by str
    The type of comparison to apply. One of: in , re, substring, less_than, less_than_or_equal, greater_than, greater_than_or_equal. Default is in.
    attribute String
    The attribute used to filter. Filter attributes are case-sensitive
    values List<String>
    The filter values. Filter values are case-sensitive. If you specify multiple values for a filter, the values are joined with an OR by default, and the request returns all results that match any of the specified values
    all Boolean

    If is set to true, the values are joined with an AND, and the requests returns only the results that match all specified values. Default is false.

    All fields in the plans block defined below can be used as attribute for both sort and filter blocks.

    matchBy String
    The type of comparison to apply. One of: in , re, substring, less_than, less_than_or_equal, greater_than, greater_than_or_equal. Default is in.

    GetPlansPlan

    AvailableInMetros List<string>
    list of metros where the plan is available
    AvailableIns List<string>
    (Deprecated) list of facilities where the plan is available

    Deprecated: Use available_in_metros instead. For more information, read the migration guide: https://registry.terraform.io/providers/equinix/equinix/latest/docs/guides/migration_guide_facilities_to_metros_devices

    Class string
    plan class
    DeploymentTypes List<string>
    list of deployment types, e.g. on_demand, spot_market
    Description string
    description of the plan
    Id string
    id of the plan
    Legacy bool
    flag showing if it's a legacy plan
    Line string
    plan line, e.g. baremetal
    Name string
    name of the plan
    PricingHour double
    plan hourly price
    PricingMonth double
    plan monthly price
    Slug string
    plan slug
    AvailableInMetros []string
    list of metros where the plan is available
    AvailableIns []string
    (Deprecated) list of facilities where the plan is available

    Deprecated: Use available_in_metros instead. For more information, read the migration guide: https://registry.terraform.io/providers/equinix/equinix/latest/docs/guides/migration_guide_facilities_to_metros_devices

    Class string
    plan class
    DeploymentTypes []string
    list of deployment types, e.g. on_demand, spot_market
    Description string
    description of the plan
    Id string
    id of the plan
    Legacy bool
    flag showing if it's a legacy plan
    Line string
    plan line, e.g. baremetal
    Name string
    name of the plan
    PricingHour float64
    plan hourly price
    PricingMonth float64
    plan monthly price
    Slug string
    plan slug
    availableInMetros List<String>
    list of metros where the plan is available
    availableIns List<String>
    (Deprecated) list of facilities where the plan is available

    Deprecated: Use available_in_metros instead. For more information, read the migration guide: https://registry.terraform.io/providers/equinix/equinix/latest/docs/guides/migration_guide_facilities_to_metros_devices

    class_ String
    plan class
    deploymentTypes List<String>
    list of deployment types, e.g. on_demand, spot_market
    description String
    description of the plan
    id String
    id of the plan
    legacy Boolean
    flag showing if it's a legacy plan
    line String
    plan line, e.g. baremetal
    name String
    name of the plan
    pricingHour Double
    plan hourly price
    pricingMonth Double
    plan monthly price
    slug String
    plan slug
    availableInMetros string[]
    list of metros where the plan is available
    availableIns string[]
    (Deprecated) list of facilities where the plan is available

    Deprecated: Use available_in_metros instead. For more information, read the migration guide: https://registry.terraform.io/providers/equinix/equinix/latest/docs/guides/migration_guide_facilities_to_metros_devices

    class string
    plan class
    deploymentTypes string[]
    list of deployment types, e.g. on_demand, spot_market
    description string
    description of the plan
    id string
    id of the plan
    legacy boolean
    flag showing if it's a legacy plan
    line string
    plan line, e.g. baremetal
    name string
    name of the plan
    pricingHour number
    plan hourly price
    pricingMonth number
    plan monthly price
    slug string
    plan slug
    available_in_metros Sequence[str]
    list of metros where the plan is available
    available_ins Sequence[str]
    (Deprecated) list of facilities where the plan is available

    Deprecated: Use available_in_metros instead. For more information, read the migration guide: https://registry.terraform.io/providers/equinix/equinix/latest/docs/guides/migration_guide_facilities_to_metros_devices

    class_ str
    plan class
    deployment_types Sequence[str]
    list of deployment types, e.g. on_demand, spot_market
    description str
    description of the plan
    id str
    id of the plan
    legacy bool
    flag showing if it's a legacy plan
    line str
    plan line, e.g. baremetal
    name str
    name of the plan
    pricing_hour float
    plan hourly price
    pricing_month float
    plan monthly price
    slug str
    plan slug
    availableInMetros List<String>
    list of metros where the plan is available
    availableIns List<String>
    (Deprecated) list of facilities where the plan is available

    Deprecated: Use available_in_metros instead. For more information, read the migration guide: https://registry.terraform.io/providers/equinix/equinix/latest/docs/guides/migration_guide_facilities_to_metros_devices

    class String
    plan class
    deploymentTypes List<String>
    list of deployment types, e.g. on_demand, spot_market
    description String
    description of the plan
    id String
    id of the plan
    legacy Boolean
    flag showing if it's a legacy plan
    line String
    plan line, e.g. baremetal
    name String
    name of the plan
    pricingHour Number
    plan hourly price
    pricingMonth Number
    plan monthly price
    slug String
    plan slug

    GetPlansSort

    Attribute string
    The attribute used to sort the results. Sort attributes are case-sensitive
    Direction string
    Sort results in ascending or descending order. Strings are sorted in alphabetical order. One of: asc, desc
    Attribute string
    The attribute used to sort the results. Sort attributes are case-sensitive
    Direction string
    Sort results in ascending or descending order. Strings are sorted in alphabetical order. One of: asc, desc
    attribute String
    The attribute used to sort the results. Sort attributes are case-sensitive
    direction String
    Sort results in ascending or descending order. Strings are sorted in alphabetical order. One of: asc, desc
    attribute string
    The attribute used to sort the results. Sort attributes are case-sensitive
    direction string
    Sort results in ascending or descending order. Strings are sorted in alphabetical order. One of: asc, desc
    attribute str
    The attribute used to sort the results. Sort attributes are case-sensitive
    direction str
    Sort results in ascending or descending order. Strings are sorted in alphabetical order. One of: asc, desc
    attribute String
    The attribute used to sort the results. Sort attributes are case-sensitive
    direction String
    Sort results in ascending or descending order. Strings are sorted in alphabetical order. One of: asc, desc

    Package Details

    Repository
    equinix equinix/pulumi-equinix
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the equinix Terraform Provider.
    equinix logo
    Equinix v0.10.0 published on Wednesday, May 22, 2024 by Equinix