Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Vcd Provider
  3. API Docs
  4. OrgVdcAccessControl
vcd 3.14.1 published on Monday, Apr 14, 2025 by vmware
vmware/terraform-provider-vcd

vcd.OrgVdcAccessControl

Explore with Pulumi AI

vcd logo
vcd 3.14.1 published on Monday, Apr 14, 2025 by vmware
vmware/terraform-provider-vcd

    Provides a VMware Cloud Director Org VDC access control resource. This can be used to share VDC across users and/or groups.

    Supported in provider v3.7+

    Note: This resource requires either system or org administrator privileges.

    Example Usage

    Example Usage 1 (Giving VDC read only access to a couple of users)

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

const my_user = vcd.getOrgUser({
    org: "my-org",
    name: "my-user",
});
const my_user2 = vcd.getOrgUser({
    org: "my-org",
    name: "my-user2",
});
const myAccessControl = new vcd.OrgVdcAccessControl("myAccessControl", {
    org: "my-org",
    vdc: "my-vdc",
    sharedWithEveryone: false,
    sharedWiths: [
        {
            userId: my_user.then(my_user => my_user.id),
            accessLevel: "ReadOnly",
        },
        {
            userId: my_user2.then(my_user2 => my_user2.id),
            accessLevel: "ReadOnly",
        },
    ],
});

    import pulumi
import pulumi_vcd as vcd

my_user = vcd.get_org_user(org="my-org",
    name="my-user")
my_user2 = vcd.get_org_user(org="my-org",
    name="my-user2")
my_access_control = vcd.OrgVdcAccessControl("myAccessControl",
    org="my-org",
    vdc="my-vdc",
    shared_with_everyone=False,
    shared_withs=[
        {
            "user_id": my_user.id,
            "access_level": "ReadOnly",
        },
        {
            "user_id": my_user2.id,
            "access_level": "ReadOnly",
        },
    ])

    package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/vcd/v3/vcd"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		my_user, err := vcd.LookupOrgUser(ctx, &vcd.LookupOrgUserArgs{
			Org:  pulumi.StringRef("my-org"),
			Name: pulumi.StringRef("my-user"),
		}, nil)
		if err != nil {
			return err
		}
		my_user2, err := vcd.LookupOrgUser(ctx, &vcd.LookupOrgUserArgs{
			Org:  pulumi.StringRef("my-org"),
			Name: pulumi.StringRef("my-user2"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = vcd.NewOrgVdcAccessControl(ctx, "myAccessControl", &vcd.OrgVdcAccessControlArgs{
			Org:                pulumi.String("my-org"),
			Vdc:                pulumi.String("my-vdc"),
			SharedWithEveryone: pulumi.Bool(false),
			SharedWiths: vcd.OrgVdcAccessControlSharedWithArray{
				&vcd.OrgVdcAccessControlSharedWithArgs{
					UserId:      pulumi.String(my_user.Id),
					AccessLevel: pulumi.String("ReadOnly"),
				},
				&vcd.OrgVdcAccessControlSharedWithArgs{
					UserId:      pulumi.String(my_user2.Id),
					AccessLevel: pulumi.String("ReadOnly"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var my_user = Vcd.GetOrgUser.Invoke(new()
    {
        Org = "my-org",
        Name = "my-user",
    });

    var my_user2 = Vcd.GetOrgUser.Invoke(new()
    {
        Org = "my-org",
        Name = "my-user2",
    });

    var myAccessControl = new Vcd.OrgVdcAccessControl("myAccessControl", new()
    {
        Org = "my-org",
        Vdc = "my-vdc",
        SharedWithEveryone = false,
        SharedWiths = new[]
        {
            new Vcd.Inputs.OrgVdcAccessControlSharedWithArgs
            {
                UserId = my_user.Apply(my_user => my_user.Apply(getOrgUserResult => getOrgUserResult.Id)),
                AccessLevel = "ReadOnly",
            },
            new Vcd.Inputs.OrgVdcAccessControlSharedWithArgs
            {
                UserId = my_user2.Apply(my_user2 => my_user2.Apply(getOrgUserResult => getOrgUserResult.Id)),
                AccessLevel = "ReadOnly",
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vcd.VcdFunctions;
import com.pulumi.vcd.inputs.GetOrgUserArgs;
import com.pulumi.vcd.OrgVdcAccessControl;
import com.pulumi.vcd.OrgVdcAccessControlArgs;
import com.pulumi.vcd.inputs.OrgVdcAccessControlSharedWithArgs;
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 my-user = VcdFunctions.getOrgUser(GetOrgUserArgs.builder()
            .org("my-org")
            .name("my-user")
            .build());

        final var my-user2 = VcdFunctions.getOrgUser(GetOrgUserArgs.builder()
            .org("my-org")
            .name("my-user2")
            .build());

        var myAccessControl = new OrgVdcAccessControl("myAccessControl", OrgVdcAccessControlArgs.builder()
            .org("my-org")
            .vdc("my-vdc")
            .sharedWithEveryone(false)
            .sharedWiths(            
                OrgVdcAccessControlSharedWithArgs.builder()
                    .userId(my_user.id())
                    .accessLevel("ReadOnly")
                    .build(),
                OrgVdcAccessControlSharedWithArgs.builder()
                    .userId(my_user2.id())
                    .accessLevel("ReadOnly")
                    .build())
            .build());

    }
}

    resources:
  myAccessControl:
    type: vcd:OrgVdcAccessControl
    properties:
      org: my-org
      # Optional
      vdc: my-vdc
      # Optional
      sharedWithEveryone: false
      sharedWiths:
        - userId: ${["my-user"].id}
          accessLevel: ReadOnly
        - userId: ${["my-user2"].id}
          accessLevel: ReadOnly
variables:
  my-user:
    fn::invoke:
      function: vcd:getOrgUser
      arguments:
        org: my-org
        name: my-user
  my-user2:
    fn::invoke:
      function: vcd:getOrgUser
      arguments:
        org: my-org
        name: my-user2

    Example Usage 2 (Giving VDC read only access to everybody)

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

const myAccessControl = new vcd.OrgVdcAccessControl("myAccessControl", {
    everyoneAccessLevel: "ReadOnly",
    org: "my-org",
    sharedWithEveryone: true,
    vdc: "my-vdc",
});
// Optional

    import pulumi
import pulumi_vcd as vcd

my_access_control = vcd.OrgVdcAccessControl("myAccessControl",
    everyone_access_level="ReadOnly",
    org="my-org",
    shared_with_everyone=True,
    vdc="my-vdc")
# Optional

    package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/vcd/v3/vcd"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := vcd.NewOrgVdcAccessControl(ctx, "myAccessControl", &vcd.OrgVdcAccessControlArgs{
			EveryoneAccessLevel: pulumi.String("ReadOnly"),
			Org:                 pulumi.String("my-org"),
			SharedWithEveryone:  pulumi.Bool(true),
			Vdc:                 pulumi.String("my-vdc"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myAccessControl = new Vcd.OrgVdcAccessControl("myAccessControl", new()
    {
        EveryoneAccessLevel = "ReadOnly",
        Org = "my-org",
        SharedWithEveryone = true,
        Vdc = "my-vdc",
    });

    // Optional
});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vcd.OrgVdcAccessControl;
import com.pulumi.vcd.OrgVdcAccessControlArgs;
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 myAccessControl = new OrgVdcAccessControl("myAccessControl", OrgVdcAccessControlArgs.builder()
            .everyoneAccessLevel("ReadOnly")
            .org("my-org")
            .sharedWithEveryone(true)
            .vdc("my-vdc")
            .build());

        // Optional
    }
}

    resources:
  myAccessControl:
    type: vcd:OrgVdcAccessControl
    properties:
      everyoneAccessLevel: ReadOnly
      org: my-org
      # Optional
      sharedWithEveryone: true
      vdc: my-vdc

    Example Usage 3 (Creating a VDC and setting VDC read only access to everybody)

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

const myVdc = new vcd.OrgVdc("myVdc", {
    allocationModel: "Flex",
    computeCapacity: {
        cpu: {
            allocated: 1024,
            limit: 1024,
        },
        memory: {
            allocated: 1024,
            limit: 1024,
        },
    },
    deleteForce: true,
    deleteRecursive: true,
    elasticity: false,
    enableFastProvisioning: true,
    enableThinProvisioning: true,
    enabled: true,
    includeVmMemoryOverhead: false,
    networkPoolName: "my-network-pool",
    org: "my-org",
    providerVdcName: "my-provider-vdc",
    storageProfiles: [{
        "default": true,
        enabled: true,
        limit: 10240,
        name: "my-storage-profile",
    }],
});
const myAccessControl = new vcd.OrgVdcAccessControl("myAccessControl", {
    everyoneAccessLevel: "ReadOnly",
    org: "my-org",
    sharedWithEveryone: true,
    vdc: "my-vdc",
});
// Optional

    import pulumi
import pulumi_vcd as vcd

my_vdc = vcd.OrgVdc("myVdc",
    allocation_model="Flex",
    compute_capacity={
        "cpu": {
            "allocated": 1024,
            "limit": 1024,
        },
        "memory": {
            "allocated": 1024,
            "limit": 1024,
        },
    },
    delete_force=True,
    delete_recursive=True,
    elasticity=False,
    enable_fast_provisioning=True,
    enable_thin_provisioning=True,
    enabled=True,
    include_vm_memory_overhead=False,
    network_pool_name="my-network-pool",
    org="my-org",
    provider_vdc_name="my-provider-vdc",
    storage_profiles=[{
        "default": True,
        "enabled": True,
        "limit": 10240,
        "name": "my-storage-profile",
    }])
my_access_control = vcd.OrgVdcAccessControl("myAccessControl",
    everyone_access_level="ReadOnly",
    org="my-org",
    shared_with_everyone=True,
    vdc="my-vdc")
# Optional

    package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/vcd/v3/vcd"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := vcd.NewOrgVdc(ctx, "myVdc", &vcd.OrgVdcArgs{
			AllocationModel: pulumi.String("Flex"),
			ComputeCapacity: &vcd.OrgVdcComputeCapacityArgs{
				Cpu: &vcd.OrgVdcComputeCapacityCpuArgs{
					Allocated: pulumi.Float64(1024),
					Limit:     pulumi.Float64(1024),
				},
				Memory: &vcd.OrgVdcComputeCapacityMemoryArgs{
					Allocated: pulumi.Float64(1024),
					Limit:     pulumi.Float64(1024),
				},
			},
			DeleteForce:             pulumi.Bool(true),
			DeleteRecursive:         pulumi.Bool(true),
			Elasticity:              pulumi.Bool(false),
			EnableFastProvisioning:  pulumi.Bool(true),
			EnableThinProvisioning:  pulumi.Bool(true),
			Enabled:                 pulumi.Bool(true),
			IncludeVmMemoryOverhead: pulumi.Bool(false),
			NetworkPoolName:         pulumi.String("my-network-pool"),
			Org:                     pulumi.String("my-org"),
			ProviderVdcName:         pulumi.String("my-provider-vdc"),
			StorageProfiles: vcd.OrgVdcStorageProfileArray{
				&vcd.OrgVdcStorageProfileArgs{
					Default: pulumi.Bool(true),
					Enabled: pulumi.Bool(true),
					Limit:   pulumi.Float64(10240),
					Name:    pulumi.String("my-storage-profile"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = vcd.NewOrgVdcAccessControl(ctx, "myAccessControl", &vcd.OrgVdcAccessControlArgs{
			EveryoneAccessLevel: pulumi.String("ReadOnly"),
			Org:                 pulumi.String("my-org"),
			SharedWithEveryone:  pulumi.Bool(true),
			Vdc:                 pulumi.String("my-vdc"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myVdc = new Vcd.OrgVdc("myVdc", new()
    {
        AllocationModel = "Flex",
        ComputeCapacity = new Vcd.Inputs.OrgVdcComputeCapacityArgs
        {
            Cpu = new Vcd.Inputs.OrgVdcComputeCapacityCpuArgs
            {
                Allocated = 1024,
                Limit = 1024,
            },
            Memory = new Vcd.Inputs.OrgVdcComputeCapacityMemoryArgs
            {
                Allocated = 1024,
                Limit = 1024,
            },
        },
        DeleteForce = true,
        DeleteRecursive = true,
        Elasticity = false,
        EnableFastProvisioning = true,
        EnableThinProvisioning = true,
        Enabled = true,
        IncludeVmMemoryOverhead = false,
        NetworkPoolName = "my-network-pool",
        Org = "my-org",
        ProviderVdcName = "my-provider-vdc",
        StorageProfiles = new[]
        {
            new Vcd.Inputs.OrgVdcStorageProfileArgs
            {
                Default = true,
                Enabled = true,
                Limit = 10240,
                Name = "my-storage-profile",
            },
        },
    });

    var myAccessControl = new Vcd.OrgVdcAccessControl("myAccessControl", new()
    {
        EveryoneAccessLevel = "ReadOnly",
        Org = "my-org",
        SharedWithEveryone = true,
        Vdc = "my-vdc",
    });

    // Optional
});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vcd.OrgVdc;
import com.pulumi.vcd.OrgVdcArgs;
import com.pulumi.vcd.inputs.OrgVdcComputeCapacityArgs;
import com.pulumi.vcd.inputs.OrgVdcComputeCapacityCpuArgs;
import com.pulumi.vcd.inputs.OrgVdcComputeCapacityMemoryArgs;
import com.pulumi.vcd.inputs.OrgVdcStorageProfileArgs;
import com.pulumi.vcd.OrgVdcAccessControl;
import com.pulumi.vcd.OrgVdcAccessControlArgs;
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 myVdc = new OrgVdc("myVdc", OrgVdcArgs.builder()
            .allocationModel("Flex")
            .computeCapacity(OrgVdcComputeCapacityArgs.builder()
                .cpu(OrgVdcComputeCapacityCpuArgs.builder()
                    .allocated("1024")
                    .limit("1024")
                    .build())
                .memory(OrgVdcComputeCapacityMemoryArgs.builder()
                    .allocated("1024")
                    .limit("1024")
                    .build())
                .build())
            .deleteForce(true)
            .deleteRecursive(true)
            .elasticity(false)
            .enableFastProvisioning(true)
            .enableThinProvisioning(true)
            .enabled(true)
            .includeVmMemoryOverhead(false)
            .networkPoolName("my-network-pool")
            .org("my-org")
            .providerVdcName("my-provider-vdc")
            .storageProfiles(OrgVdcStorageProfileArgs.builder()
                .default_(true)
                .enabled(true)
                .limit(10240)
                .name("my-storage-profile")
                .build())
            .build());

        var myAccessControl = new OrgVdcAccessControl("myAccessControl", OrgVdcAccessControlArgs.builder()
            .everyoneAccessLevel("ReadOnly")
            .org("my-org")
            .sharedWithEveryone(true)
            .vdc("my-vdc")
            .build());

        // Optional
    }
}

    resources:
  myVdc:
    type: vcd:OrgVdc
    properties:
      allocationModel: Flex
      computeCapacity:
        cpu:
          allocated: '1024'
          limit: '1024'
        memory:
          allocated: '1024'
          limit: '1024'
      deleteForce: true
      deleteRecursive: true
      elasticity: false
      enableFastProvisioning: true
      enableThinProvisioning: true
      enabled: true
      includeVmMemoryOverhead: false
      # Optional
      networkPoolName: my-network-pool
      org: my-org
      # Optional
      providerVdcName: my-provider-vdc
      storageProfiles:
        - default: true
          enabled: true
          limit: 10240
          name: my-storage-profile
  myAccessControl:
    type: vcd:OrgVdcAccessControl
    properties:
      everyoneAccessLevel: ReadOnly
      org: my-org
      # Optional
      sharedWithEveryone: true
      vdc: my-vdc

    Create OrgVdcAccessControl Resource

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

    Constructor syntax

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

@overload
def OrgVdcAccessControl(resource_name: str,
                        opts: Optional[ResourceOptions] = None,
                        shared_with_everyone: Optional[bool] = None,
                        everyone_access_level: Optional[str] = None,
                        org: Optional[str] = None,
                        org_vdc_access_control_id: Optional[str] = None,
                        shared_withs: Optional[Sequence[OrgVdcAccessControlSharedWithArgs]] = None,
                        vdc: Optional[str] = None)
    func NewOrgVdcAccessControl(ctx *Context, name string, args OrgVdcAccessControlArgs, opts ...ResourceOption) (*OrgVdcAccessControl, error)
    public OrgVdcAccessControl(string name, OrgVdcAccessControlArgs args, CustomResourceOptions? opts = null)
    public OrgVdcAccessControl(String name, OrgVdcAccessControlArgs args)
public OrgVdcAccessControl(String name, OrgVdcAccessControlArgs args, CustomResourceOptions options)

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

    Parameters

    name string
    The unique name of the resource.
    args OrgVdcAccessControlArgs
    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 OrgVdcAccessControlArgs
    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 OrgVdcAccessControlArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args OrgVdcAccessControlArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args OrgVdcAccessControlArgs
    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 orgVdcAccessControlResource = new Vcd.OrgVdcAccessControl("orgVdcAccessControlResource", new()
{
    SharedWithEveryone = false,
    EveryoneAccessLevel = "string",
    Org = "string",
    OrgVdcAccessControlId = "string",
    SharedWiths = new[]
    {
        new Vcd.Inputs.OrgVdcAccessControlSharedWithArgs
        {
            AccessLevel = "string",
            GroupId = "string",
            SubjectName = "string",
            UserId = "string",
        },
    },
    Vdc = "string",
});

    example, err := vcd.NewOrgVdcAccessControl(ctx, "orgVdcAccessControlResource", &vcd.OrgVdcAccessControlArgs{
SharedWithEveryone: pulumi.Bool(false),
EveryoneAccessLevel: pulumi.String("string"),
Org: pulumi.String("string"),
OrgVdcAccessControlId: pulumi.String("string"),
SharedWiths: .OrgVdcAccessControlSharedWithArray{
&.OrgVdcAccessControlSharedWithArgs{
AccessLevel: pulumi.String("string"),
GroupId: pulumi.String("string"),
SubjectName: pulumi.String("string"),
UserId: pulumi.String("string"),
},
},
Vdc: pulumi.String("string"),
})

    var orgVdcAccessControlResource = new OrgVdcAccessControl("orgVdcAccessControlResource", OrgVdcAccessControlArgs.builder()
    .sharedWithEveryone(false)
    .everyoneAccessLevel("string")
    .org("string")
    .orgVdcAccessControlId("string")
    .sharedWiths(OrgVdcAccessControlSharedWithArgs.builder()
        .accessLevel("string")
        .groupId("string")
        .subjectName("string")
        .userId("string")
        .build())
    .vdc("string")
    .build());

    org_vdc_access_control_resource = vcd.OrgVdcAccessControl("orgVdcAccessControlResource",
    shared_with_everyone=False,
    everyone_access_level="string",
    org="string",
    org_vdc_access_control_id="string",
    shared_withs=[{
        "access_level": "string",
        "group_id": "string",
        "subject_name": "string",
        "user_id": "string",
    }],
    vdc="string")

    const orgVdcAccessControlResource = new vcd.OrgVdcAccessControl("orgVdcAccessControlResource", {
    sharedWithEveryone: false,
    everyoneAccessLevel: "string",
    org: "string",
    orgVdcAccessControlId: "string",
    sharedWiths: [{
        accessLevel: "string",
        groupId: "string",
        subjectName: "string",
        userId: "string",
    }],
    vdc: "string",
});

    type: vcd:OrgVdcAccessControl
properties:
    everyoneAccessLevel: string
    org: string
    orgVdcAccessControlId: string
    sharedWithEveryone: false
    sharedWiths:
        - accessLevel: string
          groupId: string
          subjectName: string
          userId: string
    vdc: string

    OrgVdcAccessControl Resource Properties

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

    Inputs

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

    The OrgVdcAccessControl resource accepts the following input properties:

    SharedWithEveryone bool
    Whether the VDC is shared with everyone.
    EveryoneAccessLevel string
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    Org string
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    OrgVdcAccessControlId string
    SharedWiths List<OrgVdcAccessControlSharedWith>

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    Vdc string
    The name of VDC to use, optional if defined at provider level.
    SharedWithEveryone bool
    Whether the VDC is shared with everyone.
    EveryoneAccessLevel string
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    Org string
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    OrgVdcAccessControlId string
    SharedWiths []OrgVdcAccessControlSharedWithArgs

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    Vdc string
    The name of VDC to use, optional if defined at provider level.
    sharedWithEveryone Boolean
    Whether the VDC is shared with everyone.
    everyoneAccessLevel String
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    org String
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    orgVdcAccessControlId String
    sharedWiths List<OrgVdcAccessControlSharedWith>

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    vdc String
    The name of VDC to use, optional if defined at provider level.
    sharedWithEveryone boolean
    Whether the VDC is shared with everyone.
    everyoneAccessLevel string
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    org string
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    orgVdcAccessControlId string
    sharedWiths OrgVdcAccessControlSharedWith[]

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    vdc string
    The name of VDC to use, optional if defined at provider level.
    shared_with_everyone bool
    Whether the VDC is shared with everyone.
    everyone_access_level str
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    org str
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    org_vdc_access_control_id str
    shared_withs Sequence[OrgVdcAccessControlSharedWithArgs]

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    vdc str
    The name of VDC to use, optional if defined at provider level.
    sharedWithEveryone Boolean
    Whether the VDC is shared with everyone.
    everyoneAccessLevel String
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    org String
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    orgVdcAccessControlId String
    sharedWiths List<Property Map>

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    vdc String
    The name of VDC to use, optional if defined at provider level.

    Outputs

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

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

    Look up Existing OrgVdcAccessControl Resource

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

    public static get(name: string, id: Input<ID>, state?: OrgVdcAccessControlState, opts?: CustomResourceOptions): OrgVdcAccessControl
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        everyone_access_level: Optional[str] = None,
        org: Optional[str] = None,
        org_vdc_access_control_id: Optional[str] = None,
        shared_with_everyone: Optional[bool] = None,
        shared_withs: Optional[Sequence[OrgVdcAccessControlSharedWithArgs]] = None,
        vdc: Optional[str] = None) -> OrgVdcAccessControl
    func GetOrgVdcAccessControl(ctx *Context, name string, id IDInput, state *OrgVdcAccessControlState, opts ...ResourceOption) (*OrgVdcAccessControl, error)
    public static OrgVdcAccessControl Get(string name, Input<string> id, OrgVdcAccessControlState? state, CustomResourceOptions? opts = null)
    public static OrgVdcAccessControl get(String name, Output<String> id, OrgVdcAccessControlState state, CustomResourceOptions options)
    resources:  _:    type: vcd:OrgVdcAccessControl    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    EveryoneAccessLevel string
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    Org string
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    OrgVdcAccessControlId string
    SharedWithEveryone bool
    Whether the VDC is shared with everyone.
    SharedWiths List<OrgVdcAccessControlSharedWith>

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    Vdc string
    The name of VDC to use, optional if defined at provider level.
    EveryoneAccessLevel string
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    Org string
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    OrgVdcAccessControlId string
    SharedWithEveryone bool
    Whether the VDC is shared with everyone.
    SharedWiths []OrgVdcAccessControlSharedWithArgs

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    Vdc string
    The name of VDC to use, optional if defined at provider level.
    everyoneAccessLevel String
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    org String
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    orgVdcAccessControlId String
    sharedWithEveryone Boolean
    Whether the VDC is shared with everyone.
    sharedWiths List<OrgVdcAccessControlSharedWith>

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    vdc String
    The name of VDC to use, optional if defined at provider level.
    everyoneAccessLevel string
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    org string
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    orgVdcAccessControlId string
    sharedWithEveryone boolean
    Whether the VDC is shared with everyone.
    sharedWiths OrgVdcAccessControlSharedWith[]

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    vdc string
    The name of VDC to use, optional if defined at provider level.
    everyone_access_level str
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    org str
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    org_vdc_access_control_id str
    shared_with_everyone bool
    Whether the VDC is shared with everyone.
    shared_withs Sequence[OrgVdcAccessControlSharedWithArgs]

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    vdc str
    The name of VDC to use, optional if defined at provider level.
    everyoneAccessLevel String
    Access level when the VDC is shared with everyone (only ReadOnly is available). Required when shared_with_everyone is set.
    org String
    The name of organization to use, optional if defined at provider level. Useful when connected as sysadmin working across different organizations.
    orgVdcAccessControlId String
    sharedWithEveryone Boolean
    Whether the VDC is shared with everyone.
    sharedWiths List<Property Map>

    one or more blocks defining a subject to which we are sharing. See shared_with below for detail. It cannot be used if shared_with_everyone is set.

    Note: Users must either set sharing for everybody using shared_with_everyone and everyone_access_level arguments or per user/group access using shared_with argument. Setting both will make the resource to error.

    vdc String
    The name of VDC to use, optional if defined at provider level.

    Supporting Types

    OrgVdcAccessControlSharedWith, OrgVdcAccessControlSharedWithArgs

    AccessLevel string
    The access level for the user or group to which we are sharing. (Only ReadOnly is available)
    GroupId string
    The ID of a group which we are sharing with. Required if user_id is not set.
    SubjectName string
    The name of the subject (group or user) which we are sharing with.
    UserId string
    The ID of a user which we are sharing with. Required if group_id is not set.
    AccessLevel string
    The access level for the user or group to which we are sharing. (Only ReadOnly is available)
    GroupId string
    The ID of a group which we are sharing with. Required if user_id is not set.
    SubjectName string
    The name of the subject (group or user) which we are sharing with.
    UserId string
    The ID of a user which we are sharing with. Required if group_id is not set.
    accessLevel String
    The access level for the user or group to which we are sharing. (Only ReadOnly is available)
    groupId String
    The ID of a group which we are sharing with. Required if user_id is not set.
    subjectName String
    The name of the subject (group or user) which we are sharing with.
    userId String
    The ID of a user which we are sharing with. Required if group_id is not set.
    accessLevel string
    The access level for the user or group to which we are sharing. (Only ReadOnly is available)
    groupId string
    The ID of a group which we are sharing with. Required if user_id is not set.
    subjectName string
    The name of the subject (group or user) which we are sharing with.
    userId string
    The ID of a user which we are sharing with. Required if group_id is not set.
    access_level str
    The access level for the user or group to which we are sharing. (Only ReadOnly is available)
    group_id str
    The ID of a group which we are sharing with. Required if user_id is not set.
    subject_name str
    The name of the subject (group or user) which we are sharing with.
    user_id str
    The ID of a user which we are sharing with. Required if group_id is not set.
    accessLevel String
    The access level for the user or group to which we are sharing. (Only ReadOnly is available)
    groupId String
    The ID of a group which we are sharing with. Required if user_id is not set.
    subjectName String
    The name of the subject (group or user) which we are sharing with.
    userId String
    The ID of a user which we are sharing with. Required if group_id is not set.

    Package Details

    Repository
    vcd vmware/terraform-provider-vcd
    License
    Notes
    This Pulumi package is based on the vcd Terraform Provider.
    vcd logo
    vcd 3.14.1 published on Monday, Apr 14, 2025 by vmware
    vmware/terraform-provider-vcd