1. Packages
  2. Equinix
  3. API Docs
  4. fabric
  5. getConnectionRouteAggregation
Equinix v0.27.1 published on Wednesday, Oct 29, 2025 by Equinix
equinix/pulumi-equinix

equinix.fabric.getConnectionRouteAggregation

Start a Neo task
Explain and create an equinix.fabric.getConnectionRouteAggregation resource
equinix logo
Equinix v0.27.1 published on Wednesday, Oct 29, 2025 by Equinix
equinix/pulumi-equinix

    Fabric V4 API compatible data resource that allow user to fetch Equinix Fabric Connection Route Aggregation by UUID Additional Documentation:

    • API: https://developer.equinix.com/catalog/fabricv4#tag/Route-Aggregations

    Example Usage

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

const attachedPolicy = equinix.fabric.getConnectionRouteAggregation({
    routeAggregationId: "<route_aggregation_id>",
    connectionId: "<connection_id>",
});
export const connectionRouteAggregationId = attachedPolicy.then(attachedPolicy => attachedPolicy.id);
export const connectionRouteAggregationConnectionId = attachedPolicy.then(attachedPolicy => attachedPolicy.connectionId);
export const connectionRouteAggregationType = attachedPolicy.then(attachedPolicy => attachedPolicy.type);
export const connectionRouteAggregationAttachmentStatus = attachedPolicy.then(attachedPolicy => attachedPolicy.attachmentStatus);

    import pulumi
import pulumi_equinix as equinix

attached_policy = equinix.fabric.get_connection_route_aggregation(route_aggregation_id="<route_aggregation_id>",
    connection_id="<connection_id>")
pulumi.export("connectionRouteAggregationId", attached_policy.id)
pulumi.export("connectionRouteAggregationConnectionId", attached_policy.connection_id)
pulumi.export("connectionRouteAggregationType", attached_policy.type)
pulumi.export("connectionRouteAggregationAttachmentStatus", attached_policy.attachment_status)

    package main

import (
	"github.com/equinix/pulumi-equinix/sdk/go/equinix/fabric"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		attachedPolicy, err := fabric.LookupConnectionRouteAggregation(ctx, &fabric.LookupConnectionRouteAggregationArgs{
			RouteAggregationId: "<route_aggregation_id>",
			ConnectionId:       "<connection_id>",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("connectionRouteAggregationId", attachedPolicy.Id)
		ctx.Export("connectionRouteAggregationConnectionId", attachedPolicy.ConnectionId)
		ctx.Export("connectionRouteAggregationType", attachedPolicy.Type)
		ctx.Export("connectionRouteAggregationAttachmentStatus", attachedPolicy.AttachmentStatus)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var attachedPolicy = Equinix.Fabric.GetConnectionRouteAggregation.Invoke(new()
    {
        RouteAggregationId = "<route_aggregation_id>",
        ConnectionId = "<connection_id>",
    });

    return new Dictionary<string, object?>
    {
        ["connectionRouteAggregationId"] = attachedPolicy.Apply(getConnectionRouteAggregationResult => getConnectionRouteAggregationResult.Id),
        ["connectionRouteAggregationConnectionId"] = attachedPolicy.Apply(getConnectionRouteAggregationResult => getConnectionRouteAggregationResult.ConnectionId),
        ["connectionRouteAggregationType"] = attachedPolicy.Apply(getConnectionRouteAggregationResult => getConnectionRouteAggregationResult.Type),
        ["connectionRouteAggregationAttachmentStatus"] = attachedPolicy.Apply(getConnectionRouteAggregationResult => getConnectionRouteAggregationResult.AttachmentStatus),
    };
});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.equinix.fabric.FabricFunctions;
import com.pulumi.equinix.fabric.inputs.GetConnectionRouteAggregationArgs;
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 attachedPolicy = FabricFunctions.getConnectionRouteAggregation(GetConnectionRouteAggregationArgs.builder()
            .routeAggregationId("<route_aggregation_id>")
            .connectionId("<connection_id>")
            .build());

        ctx.export("connectionRouteAggregationId", attachedPolicy.applyValue(getConnectionRouteAggregationResult -> getConnectionRouteAggregationResult.id()));
        ctx.export("connectionRouteAggregationConnectionId", attachedPolicy.applyValue(getConnectionRouteAggregationResult -> getConnectionRouteAggregationResult.connectionId()));
        ctx.export("connectionRouteAggregationType", attachedPolicy.applyValue(getConnectionRouteAggregationResult -> getConnectionRouteAggregationResult.type()));
        ctx.export("connectionRouteAggregationAttachmentStatus", attachedPolicy.applyValue(getConnectionRouteAggregationResult -> getConnectionRouteAggregationResult.attachmentStatus()));
    }
}

    variables:
  attachedPolicy:
    fn::invoke:
      function: equinix:fabric:getConnectionRouteAggregation
      arguments:
        routeAggregationId: <route_aggregation_id>
        connectionId: <connection_id>
outputs:
  connectionRouteAggregationId: ${attachedPolicy.id}
  connectionRouteAggregationConnectionId: ${attachedPolicy.connectionId}
  connectionRouteAggregationType: ${attachedPolicy.type}
  connectionRouteAggregationAttachmentStatus: ${attachedPolicy.attachmentStatus}

    Using getConnectionRouteAggregation

    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 getConnectionRouteAggregation(args: GetConnectionRouteAggregationArgs, opts?: InvokeOptions): Promise<GetConnectionRouteAggregationResult>
function getConnectionRouteAggregationOutput(args: GetConnectionRouteAggregationOutputArgs, opts?: InvokeOptions): Output<GetConnectionRouteAggregationResult>
    def get_connection_route_aggregation(connection_id: Optional[str] = None,
                                     route_aggregation_id: Optional[str] = None,
                                     opts: Optional[InvokeOptions] = None) -> GetConnectionRouteAggregationResult
def get_connection_route_aggregation_output(connection_id: Optional[pulumi.Input[str]] = None,
                                     route_aggregation_id: Optional[pulumi.Input[str]] = None,
                                     opts: Optional[InvokeOptions] = None) -> Output[GetConnectionRouteAggregationResult]
    func LookupConnectionRouteAggregation(ctx *Context, args *LookupConnectionRouteAggregationArgs, opts ...InvokeOption) (*LookupConnectionRouteAggregationResult, error)
func LookupConnectionRouteAggregationOutput(ctx *Context, args *LookupConnectionRouteAggregationOutputArgs, opts ...InvokeOption) LookupConnectionRouteAggregationResultOutput

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

    public static class GetConnectionRouteAggregation 
{
    public static Task<GetConnectionRouteAggregationResult> InvokeAsync(GetConnectionRouteAggregationArgs args, InvokeOptions? opts = null)
    public static Output<GetConnectionRouteAggregationResult> Invoke(GetConnectionRouteAggregationInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<GetConnectionRouteAggregationResult> getConnectionRouteAggregation(GetConnectionRouteAggregationArgs args, InvokeOptions options)
public static Output<GetConnectionRouteAggregationResult> getConnectionRouteAggregation(GetConnectionRouteAggregationArgs args, InvokeOptions options)

    fn::invoke:
  function: equinix:fabric/getConnectionRouteAggregation:getConnectionRouteAggregation
  arguments:
    # arguments dictionary

    The following arguments are supported:

    ConnectionId string
    The uuid of the connection this data source should retrieve
    RouteAggregationId string
    The uuid of the route aggregation this data source should retrieve
    ConnectionId string
    The uuid of the connection this data source should retrieve
    RouteAggregationId string
    The uuid of the route aggregation this data source should retrieve
    connectionId String
    The uuid of the connection this data source should retrieve
    routeAggregationId String
    The uuid of the route aggregation this data source should retrieve
    connectionId string
    The uuid of the connection this data source should retrieve
    routeAggregationId string
    The uuid of the route aggregation this data source should retrieve
    connection_id str
    The uuid of the connection this data source should retrieve
    route_aggregation_id str
    The uuid of the route aggregation this data source should retrieve
    connectionId String
    The uuid of the connection this data source should retrieve
    routeAggregationId String
    The uuid of the route aggregation this data source should retrieve

    getConnectionRouteAggregation Result

    The following output properties are available:

    AttachmentStatus string
    Status of the Route Aggregation Policy attachment lifecycle
    ConnectionId string
    The uuid of the connection this data source should retrieve
    Href string
    URI to the attached Route Aggregation Policy on the Connection
    Id string
    The unique identifier of the resource
    RouteAggregationId string
    The uuid of the route aggregation this data source should retrieve
    Type string
    Route Aggregation Type. One of ["BGPIPv4PREFIX_AGGREGATION"]
    Uuid string
    Equinix Assigned ID for Route Aggregation Policy
    AttachmentStatus string
    Status of the Route Aggregation Policy attachment lifecycle
    ConnectionId string
    The uuid of the connection this data source should retrieve
    Href string
    URI to the attached Route Aggregation Policy on the Connection
    Id string
    The unique identifier of the resource
    RouteAggregationId string
    The uuid of the route aggregation this data source should retrieve
    Type string
    Route Aggregation Type. One of ["BGPIPv4PREFIX_AGGREGATION"]
    Uuid string
    Equinix Assigned ID for Route Aggregation Policy
    attachmentStatus String
    Status of the Route Aggregation Policy attachment lifecycle
    connectionId String
    The uuid of the connection this data source should retrieve
    href String
    URI to the attached Route Aggregation Policy on the Connection
    id String
    The unique identifier of the resource
    routeAggregationId String
    The uuid of the route aggregation this data source should retrieve
    type String
    Route Aggregation Type. One of ["BGPIPv4PREFIX_AGGREGATION"]
    uuid String
    Equinix Assigned ID for Route Aggregation Policy
    attachmentStatus string
    Status of the Route Aggregation Policy attachment lifecycle
    connectionId string
    The uuid of the connection this data source should retrieve
    href string
    URI to the attached Route Aggregation Policy on the Connection
    id string
    The unique identifier of the resource
    routeAggregationId string
    The uuid of the route aggregation this data source should retrieve
    type string
    Route Aggregation Type. One of ["BGPIPv4PREFIX_AGGREGATION"]
    uuid string
    Equinix Assigned ID for Route Aggregation Policy
    attachment_status str
    Status of the Route Aggregation Policy attachment lifecycle
    connection_id str
    The uuid of the connection this data source should retrieve
    href str
    URI to the attached Route Aggregation Policy on the Connection
    id str
    The unique identifier of the resource
    route_aggregation_id str
    The uuid of the route aggregation this data source should retrieve
    type str
    Route Aggregation Type. One of ["BGPIPv4PREFIX_AGGREGATION"]
    uuid str
    Equinix Assigned ID for Route Aggregation Policy
    attachmentStatus String
    Status of the Route Aggregation Policy attachment lifecycle
    connectionId String
    The uuid of the connection this data source should retrieve
    href String
    URI to the attached Route Aggregation Policy on the Connection
    id String
    The unique identifier of the resource
    routeAggregationId String
    The uuid of the route aggregation this data source should retrieve
    type String
    Route Aggregation Type. One of ["BGPIPv4PREFIX_AGGREGATION"]
    uuid String
    Equinix Assigned ID for Route Aggregation Policy

    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.27.1 published on Wednesday, Oct 29, 2025 by Equinix
    equinix/pulumi-equinix
      Meet Neo: Your AI Platform Teammate