getSidecarBoundPorts

cyral 4.16.3, Apr 14 25

Viewing docs for cyral 4.16.3
published on Monday, Apr 14, 2025 by cyralinc

Schema (JSON)

cyralinc/terraform-provider-cyral

Viewing docs for cyral 4.16.3
published on Monday, Apr 14, 2025 by cyralinc

Schema (JSON)

cyralinc/terraform-provider-cyral

# cyral.getSidecarBoundPorts (Data Source)

Retrieves all the ports of a given sidecar that are currently bound to repositories.

Example Usage

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

const sidecar = new cyral.Sidecar("sidecar", {deploymentMethod: "docker"});
const repo_1 = new cyral.Repository("repo-1", {
    type: "mongodb",
    repoNodes: [{
        host: "mongodb.cyral.com",
        port: 27017,
    }],
});
const listener_1 = new cyral.SidecarListener("listener-1", {
    sidecarId: sidecar.id,
    repoTypes: ["mongodb"],
    networkAddress: {
        host: "mongodb.cyral.com",
        port: 27017,
    },
});
const binding_1 = new cyral.RepositoryBinding("binding-1", {
    sidecarId: sidecar.id,
    repositoryId: repo_1.id,
    enabled: true,
    listenerBindings: [{
        listenerId: listener_1.listenerId,
        nodeIndex: 0,
    }],
});
const repo_2 = new cyral.Repository("repo-2", {
    type: "mongodb",
    repoNodes: [{
        host: "mongodb.cyral.com",
        port: 27018,
    }],
});
const listener_2 = new cyral.SidecarListener("listener-2", {
    sidecarId: sidecar.id,
    repoTypes: ["mongodb"],
    networkAddress: {
        host: "mongodb.cyral.com",
        port: 27017,
    },
});
const binding_2 = new cyral.RepositoryBinding("binding-2", {
    sidecarId: sidecar.id,
    repositoryId: repo_2.id,
    enabled: true,
    listenerBindings: [{
        listenerId: listener_2.listenerId,
        nodeIndex: 0,
    }],
});
const _this = cyral.getSidecarBoundPortsOutput({
    sidecarId: sidecar.id,
});
export const sidecarBoundPorts = _this.apply(_this => _this.boundPorts);

import pulumi
import pulumi_cyral as cyral

sidecar = cyral.Sidecar("sidecar", deployment_method="docker")
repo_1 = cyral.Repository("repo-1",
    type="mongodb",
    repo_nodes=[{
        "host": "mongodb.cyral.com",
        "port": 27017,
    }])
listener_1 = cyral.SidecarListener("listener-1",
    sidecar_id=sidecar.id,
    repo_types=["mongodb"],
    network_address={
        "host": "mongodb.cyral.com",
        "port": 27017,
    })
binding_1 = cyral.RepositoryBinding("binding-1",
    sidecar_id=sidecar.id,
    repository_id=repo_1.id,
    enabled=True,
    listener_bindings=[{
        "listener_id": listener_1.listener_id,
        "node_index": 0,
    }])
repo_2 = cyral.Repository("repo-2",
    type="mongodb",
    repo_nodes=[{
        "host": "mongodb.cyral.com",
        "port": 27018,
    }])
listener_2 = cyral.SidecarListener("listener-2",
    sidecar_id=sidecar.id,
    repo_types=["mongodb"],
    network_address={
        "host": "mongodb.cyral.com",
        "port": 27017,
    })
binding_2 = cyral.RepositoryBinding("binding-2",
    sidecar_id=sidecar.id,
    repository_id=repo_2.id,
    enabled=True,
    listener_bindings=[{
        "listener_id": listener_2.listener_id,
        "node_index": 0,
    }])
this = cyral.get_sidecar_bound_ports_output(sidecar_id=sidecar.id)
pulumi.export("sidecarBoundPorts", this.bound_ports)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/cyral/v4/cyral"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
sidecar, err := cyral.NewSidecar(ctx, "sidecar", &cyral.SidecarArgs{
DeploymentMethod: pulumi.String("docker"),
})
if err != nil {
return err
}
repo_1, err := cyral.NewRepository(ctx, "repo-1", &cyral.RepositoryArgs{
Type: pulumi.String("mongodb"),
RepoNodes: cyral.RepositoryRepoNodeArray{
&cyral.RepositoryRepoNodeArgs{
Host: pulumi.String("mongodb.cyral.com"),
Port: pulumi.Float64(27017),
},
},
})
if err != nil {
return err
}
listener_1, err := cyral.NewSidecarListener(ctx, "listener-1", &cyral.SidecarListenerArgs{
SidecarId: sidecar.ID(),
RepoTypes: pulumi.StringArray{
pulumi.String("mongodb"),
},
NetworkAddress: &cyral.SidecarListenerNetworkAddressArgs{
Host: pulumi.String("mongodb.cyral.com"),
Port: pulumi.Float64(27017),
},
})
if err != nil {
return err
}
_, err = cyral.NewRepositoryBinding(ctx, "binding-1", &cyral.RepositoryBindingArgs{
SidecarId: sidecar.ID(),
RepositoryId: repo_1.ID(),
Enabled: pulumi.Bool(true),
ListenerBindings: cyral.RepositoryBindingListenerBindingArray{
&cyral.RepositoryBindingListenerBindingArgs{
ListenerId: listener_1.ListenerId,
NodeIndex: pulumi.Float64(0),
},
},
})
if err != nil {
return err
}
repo_2, err := cyral.NewRepository(ctx, "repo-2", &cyral.RepositoryArgs{
Type: pulumi.String("mongodb"),
RepoNodes: cyral.RepositoryRepoNodeArray{
&cyral.RepositoryRepoNodeArgs{
Host: pulumi.String("mongodb.cyral.com"),
Port: pulumi.Float64(27018),
},
},
})
if err != nil {
return err
}
listener_2, err := cyral.NewSidecarListener(ctx, "listener-2", &cyral.SidecarListenerArgs{
SidecarId: sidecar.ID(),
RepoTypes: pulumi.StringArray{
pulumi.String("mongodb"),
},
NetworkAddress: &cyral.SidecarListenerNetworkAddressArgs{
Host: pulumi.String("mongodb.cyral.com"),
Port: pulumi.Float64(27017),
},
})
if err != nil {
return err
}
_, err = cyral.NewRepositoryBinding(ctx, "binding-2", &cyral.RepositoryBindingArgs{
SidecarId: sidecar.ID(),
RepositoryId: repo_2.ID(),
Enabled: pulumi.Bool(true),
ListenerBindings: cyral.RepositoryBindingListenerBindingArray{
&cyral.RepositoryBindingListenerBindingArgs{
ListenerId: listener_2.ListenerId,
NodeIndex: pulumi.Float64(0),
},
},
})
if err != nil {
return err
}
this := cyral.GetSidecarBoundPortsOutput(ctx, cyral.GetSidecarBoundPortsOutputArgs{
SidecarId: sidecar.ID(),
}, nil);
ctx.Export("sidecarBoundPorts", this.ApplyT(func(this cyral.GetSidecarBoundPortsResult) (interface{}, error) {
return this.BoundPorts, nil
}).(pulumi.Interface{}Output))
return nil
})
}

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

return await Deployment.RunAsync(() => 
{
    var sidecar = new Cyral.Sidecar("sidecar", new()
    {
        DeploymentMethod = "docker",
    });

    var repo_1 = new Cyral.Repository("repo-1", new()
    {
        Type = "mongodb",
        RepoNodes = new[]
        {
            new Cyral.Inputs.RepositoryRepoNodeArgs
            {
                Host = "mongodb.cyral.com",
                Port = 27017,
            },
        },
    });

    var listener_1 = new Cyral.SidecarListener("listener-1", new()
    {
        SidecarId = sidecar.Id,
        RepoTypes = new[]
        {
            "mongodb",
        },
        NetworkAddress = new Cyral.Inputs.SidecarListenerNetworkAddressArgs
        {
            Host = "mongodb.cyral.com",
            Port = 27017,
        },
    });

    var binding_1 = new Cyral.RepositoryBinding("binding-1", new()
    {
        SidecarId = sidecar.Id,
        RepositoryId = repo_1.Id,
        Enabled = true,
        ListenerBindings = new[]
        {
            new Cyral.Inputs.RepositoryBindingListenerBindingArgs
            {
                ListenerId = listener_1.ListenerId,
                NodeIndex = 0,
            },
        },
    });

    var repo_2 = new Cyral.Repository("repo-2", new()
    {
        Type = "mongodb",
        RepoNodes = new[]
        {
            new Cyral.Inputs.RepositoryRepoNodeArgs
            {
                Host = "mongodb.cyral.com",
                Port = 27018,
            },
        },
    });

    var listener_2 = new Cyral.SidecarListener("listener-2", new()
    {
        SidecarId = sidecar.Id,
        RepoTypes = new[]
        {
            "mongodb",
        },
        NetworkAddress = new Cyral.Inputs.SidecarListenerNetworkAddressArgs
        {
            Host = "mongodb.cyral.com",
            Port = 27017,
        },
    });

    var binding_2 = new Cyral.RepositoryBinding("binding-2", new()
    {
        SidecarId = sidecar.Id,
        RepositoryId = repo_2.Id,
        Enabled = true,
        ListenerBindings = new[]
        {
            new Cyral.Inputs.RepositoryBindingListenerBindingArgs
            {
                ListenerId = listener_2.ListenerId,
                NodeIndex = 0,
            },
        },
    });

    var @this = Cyral.GetSidecarBoundPorts.Invoke(new()
    {
        SidecarId = sidecar.Id,
    });

    return new Dictionary<string, object?>
    {
        ["sidecarBoundPorts"] = @this.Apply(@this => @this.Apply(getSidecarBoundPortsResult => getSidecarBoundPortsResult.BoundPorts)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.cyral.Sidecar;
import com.pulumi.cyral.SidecarArgs;
import com.pulumi.cyral.Repository;
import com.pulumi.cyral.RepositoryArgs;
import com.pulumi.cyral.inputs.RepositoryRepoNodeArgs;
import com.pulumi.cyral.SidecarListener;
import com.pulumi.cyral.SidecarListenerArgs;
import com.pulumi.cyral.inputs.SidecarListenerNetworkAddressArgs;
import com.pulumi.cyral.RepositoryBinding;
import com.pulumi.cyral.RepositoryBindingArgs;
import com.pulumi.cyral.inputs.RepositoryBindingListenerBindingArgs;
import com.pulumi.cyral.CyralFunctions;
import com.pulumi.cyral.inputs.GetSidecarBoundPortsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var sidecar = new Sidecar("sidecar", SidecarArgs.builder()
            .deploymentMethod("docker")
            .build());

        var repo_1 = new Repository("repo-1", RepositoryArgs.builder()
            .type("mongodb")
            .repoNodes(RepositoryRepoNodeArgs.builder()
                .host("mongodb.cyral.com")
                .port(27017)
                .build())
            .build());

        var listener_1 = new SidecarListener("listener-1", SidecarListenerArgs.builder()
            .sidecarId(sidecar.id())
            .repoTypes("mongodb")
            .networkAddress(SidecarListenerNetworkAddressArgs.builder()
                .host("mongodb.cyral.com")
                .port(27017)
                .build())
            .build());

        var binding_1 = new RepositoryBinding("binding-1", RepositoryBindingArgs.builder()
            .sidecarId(sidecar.id())
            .repositoryId(repo_1.id())
            .enabled(true)
            .listenerBindings(RepositoryBindingListenerBindingArgs.builder()
                .listenerId(listener_1.listenerId())
                .nodeIndex(0)
                .build())
            .build());

        var repo_2 = new Repository("repo-2", RepositoryArgs.builder()
            .type("mongodb")
            .repoNodes(RepositoryRepoNodeArgs.builder()
                .host("mongodb.cyral.com")
                .port(27018)
                .build())
            .build());

        var listener_2 = new SidecarListener("listener-2", SidecarListenerArgs.builder()
            .sidecarId(sidecar.id())
            .repoTypes("mongodb")
            .networkAddress(SidecarListenerNetworkAddressArgs.builder()
                .host("mongodb.cyral.com")
                .port(27017)
                .build())
            .build());

        var binding_2 = new RepositoryBinding("binding-2", RepositoryBindingArgs.builder()
            .sidecarId(sidecar.id())
            .repositoryId(repo_2.id())
            .enabled(true)
            .listenerBindings(RepositoryBindingListenerBindingArgs.builder()
                .listenerId(listener_2.listenerId())
                .nodeIndex(0)
                .build())
            .build());

        final var this = CyralFunctions.getSidecarBoundPorts(GetSidecarBoundPortsArgs.builder()
            .sidecarId(sidecar.id())
            .build());

        ctx.export("sidecarBoundPorts", this_.applyValue(this_ -> this_.boundPorts()));
    }
}

resources:
  sidecar:
    type: cyral:Sidecar
    properties:
      deploymentMethod: docker
  repo-1:
    type: cyral:Repository
    properties:
      type: mongodb
      repoNodes:
        - host: mongodb.cyral.com
          port: 27017
  listener-1:
    type: cyral:SidecarListener
    properties:
      sidecarId: ${sidecar.id}
      repoTypes:
        - mongodb
      networkAddress:
        host: mongodb.cyral.com
        port: 27017
  binding-1:
    type: cyral:RepositoryBinding
    properties:
      sidecarId: ${sidecar.id}
      repositoryId: ${["repo-1"].id}
      enabled: true
      listenerBindings:
        - listenerId: ${["listener-1"].listenerId}
          nodeIndex: 0
  repo-2:
    type: cyral:Repository
    properties:
      type: mongodb
      repoNodes:
        - host: mongodb.cyral.com
          port: 27018
  listener-2:
    type: cyral:SidecarListener
    properties:
      sidecarId: ${sidecar.id}
      repoTypes:
        - mongodb
      networkAddress:
        host: mongodb.cyral.com
        port: 27017
  binding-2:
    type: cyral:RepositoryBinding
    properties:
      sidecarId: ${sidecar.id}
      repositoryId: ${["repo-2"].id}
      enabled: true
      listenerBindings:
        - listenerId: ${["listener-2"].listenerId}
          nodeIndex: 0
variables:
  this:
    fn::invoke:
      function: cyral:getSidecarBoundPorts
      arguments:
        sidecarId: ${sidecar.id}
outputs:
  sidecarBoundPorts: ${this.boundPorts}

Using getSidecarBoundPorts

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 getSidecarBoundPorts(args: GetSidecarBoundPortsArgs, opts?: InvokeOptions): Promise<GetSidecarBoundPortsResult>
function getSidecarBoundPortsOutput(args: GetSidecarBoundPortsOutputArgs, opts?: InvokeOptions): Output<GetSidecarBoundPortsResult>

def get_sidecar_bound_ports(sidecar_id: Optional[str] = None,
                            opts: Optional[InvokeOptions] = None) -> GetSidecarBoundPortsResult
def get_sidecar_bound_ports_output(sidecar_id: Optional[pulumi.Input[str]] = None,
                            opts: Optional[InvokeOptions] = None) -> Output[GetSidecarBoundPortsResult]

func GetSidecarBoundPorts(ctx *Context, args *GetSidecarBoundPortsArgs, opts ...InvokeOption) (*GetSidecarBoundPortsResult, error)
func GetSidecarBoundPortsOutput(ctx *Context, args *GetSidecarBoundPortsOutputArgs, opts ...InvokeOption) GetSidecarBoundPortsResultOutput

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

public static class GetSidecarBoundPorts 
{
    public static Task<GetSidecarBoundPortsResult> InvokeAsync(GetSidecarBoundPortsArgs args, InvokeOptions? opts = null)
    public static Output<GetSidecarBoundPortsResult> Invoke(GetSidecarBoundPortsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSidecarBoundPortsResult> getSidecarBoundPorts(GetSidecarBoundPortsArgs args, InvokeOptions options)
public static Output<GetSidecarBoundPortsResult> getSidecarBoundPorts(GetSidecarBoundPortsArgs args, InvokeOptions options)

fn::invoke:
  function: cyral:index/getSidecarBoundPorts:getSidecarBoundPorts
  arguments:
    # arguments dictionary

The following arguments are supported:

SidecarId string: The ID of the sidecar.

SidecarId string: The ID of the sidecar.

sidecarId String: The ID of the sidecar.

sidecarId string: The ID of the sidecar.

sidecar_id str: The ID of the sidecar.

sidecarId String: The ID of the sidecar.