Skip to content
v2.278.0

CfnPrincipalPermissionsProps Struct ​

Properties for defining a CfnPrincipalPermissions.

Example ​

ts
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import { aws_lakeformation as lakeformation } from 'aws-cdk-lib';

declare const catalog: any;
declare const tableWildcard: any;
const cfnPrincipalPermissionsProps: lakeformation.CfnPrincipalPermissionsProps = {
  permissions: ['permissions'],
  permissionsWithGrantOption: ['permissionsWithGrantOption'],
  principal: {
    dataLakePrincipalIdentifier: 'dataLakePrincipalIdentifier',
  },
  resource: {
    catalog: catalog,
    database: {
      catalogId: 'catalogId',
      name: 'name',
    },
    dataCellsFilter: {
      databaseName: 'databaseName',
      name: 'name',
      tableCatalogId: 'tableCatalogId',
      tableName: 'tableName',
    },
    dataLocation: {
      catalogId: 'catalogId',
      resourceArn: 'resourceArn',
    },
    lfTag: {
      catalogId: 'catalogId',
      tagKey: 'tagKey',
      tagValues: ['tagValues'],
    },
    lfTagPolicy: {
      catalogId: 'catalogId',
      expression: [{
        tagKey: 'tagKey',
        tagValues: ['tagValues'],
      }],
      resourceType: 'resourceType',
    },
    table: {
      catalogId: 'catalogId',
      databaseName: 'databaseName',

      // the properties below are optional
      name: 'name',
      tableWildcard: tableWildcard,
    },
    tableWithColumns: {
      catalogId: 'catalogId',
      databaseName: 'databaseName',
      name: 'name',

      // the properties below are optional
      columnNames: ['columnNames'],
      columnWildcard: {
        excludedColumnNames: ['excludedColumnNames'],
      },
    },
  },

  // the properties below are optional
  catalog: 'catalog',
};
python
# The code below shows an example of how to instantiate this type.
# The values are placeholders you should change.
from aws_cdk import aws_lakeformation as lakeformation

# catalog: Any
# table_wildcard: Any

cfn_principal_permissions_props = lakeformation.CfnPrincipalPermissionsProps(
    permissions=["permissions"],
    permissions_with_grant_option=["permissionsWithGrantOption"],
    principal=lakeformation.CfnPrincipalPermissions.DataLakePrincipalProperty(
        data_lake_principal_identifier="dataLakePrincipalIdentifier"
    ),
    resource=lakeformation.CfnPrincipalPermissions.ResourceProperty(
        catalog=catalog,
        database=lakeformation.CfnPrincipalPermissions.DatabaseResourceProperty(
            catalog_id="catalogId",
            name="name"
        ),
        data_cells_filter=lakeformation.CfnPrincipalPermissions.DataCellsFilterResourceProperty(
            database_name="databaseName",
            name="name",
            table_catalog_id="tableCatalogId",
            table_name="tableName"
        ),
        data_location=lakeformation.CfnPrincipalPermissions.DataLocationResourceProperty(
            catalog_id="catalogId",
            resource_arn="resourceArn"
        ),
        lf_tag=lakeformation.CfnPrincipalPermissions.LFTagKeyResourceProperty(
            catalog_id="catalogId",
            tag_key="tagKey",
            tag_values=["tagValues"]
        ),
        lf_tag_policy=lakeformation.CfnPrincipalPermissions.LFTagPolicyResourceProperty(
            catalog_id="catalogId",
            expression=[lakeformation.CfnPrincipalPermissions.LFTagProperty(
                tag_key="tagKey",
                tag_values=["tagValues"]
            )],
            resource_type="resourceType"
        ),
        table=lakeformation.CfnPrincipalPermissions.TableResourceProperty(
            catalog_id="catalogId",
            database_name="databaseName",

            # the properties below are optional
            name="name",
            table_wildcard=table_wildcard
        ),
        table_with_columns=lakeformation.CfnPrincipalPermissions.TableWithColumnsResourceProperty(
            catalog_id="catalogId",
            database_name="databaseName",
            name="name",

            # the properties below are optional
            column_names=["columnNames"],
            column_wildcard=lakeformation.CfnPrincipalPermissions.ColumnWildcardProperty(
                excluded_column_names=["excludedColumnNames"]
            )
        )
    ),

    # the properties below are optional
    catalog="catalog"
)
java
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import software.amazon.awscdk.services.lakeformation.*;

Object catalog;
Object tableWildcard;

CfnPrincipalPermissionsProps cfnPrincipalPermissionsProps = CfnPrincipalPermissionsProps.builder()
        .permissions(List.of("permissions"))
        .permissionsWithGrantOption(List.of("permissionsWithGrantOption"))
        .principal(DataLakePrincipalProperty.builder()
                .dataLakePrincipalIdentifier("dataLakePrincipalIdentifier")
                .build())
        .resource(ResourceProperty.builder()
                .catalog(catalog)
                .database(DatabaseResourceProperty.builder()
                        .catalogId("catalogId")
                        .name("name")
                        .build())
                .dataCellsFilter(DataCellsFilterResourceProperty.builder()
                        .databaseName("databaseName")
                        .name("name")
                        .tableCatalogId("tableCatalogId")
                        .tableName("tableName")
                        .build())
                .dataLocation(DataLocationResourceProperty.builder()
                        .catalogId("catalogId")
                        .resourceArn("resourceArn")
                        .build())
                .lfTag(LFTagKeyResourceProperty.builder()
                        .catalogId("catalogId")
                        .tagKey("tagKey")
                        .tagValues(List.of("tagValues"))
                        .build())
                .lfTagPolicy(LFTagPolicyResourceProperty.builder()
                        .catalogId("catalogId")
                        .expression(List.of(LFTagProperty.builder()
                                .tagKey("tagKey")
                                .tagValues(List.of("tagValues"))
                                .build()))
                        .resourceType("resourceType")
                        .build())
                .table(TableResourceProperty.builder()
                        .catalogId("catalogId")
                        .databaseName("databaseName")

                        // the properties below are optional
                        .name("name")
                        .tableWildcard(tableWildcard)
                        .build())
                .tableWithColumns(TableWithColumnsResourceProperty.builder()
                        .catalogId("catalogId")
                        .databaseName("databaseName")
                        .name("name")

                        // the properties below are optional
                        .columnNames(List.of("columnNames"))
                        .columnWildcard(ColumnWildcardProperty.builder()
                                .excludedColumnNames(List.of("excludedColumnNames"))
                                .build())
                        .build())
                .build())

        // the properties below are optional
        .catalog("catalog")
        .build();
csharp
// Install: dotnet add package Amazon.CDK.Lib
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
using Amazon.CDK.AWS.LakeFormation;

var catalog;
var tableWildcard;

var cfnPrincipalPermissionsProps = new CfnPrincipalPermissionsProps {
    Permissions = new [] { "permissions" },
    PermissionsWithGrantOption = new [] { "permissionsWithGrantOption" },
    Principal = new DataLakePrincipalProperty {
        DataLakePrincipalIdentifier = "dataLakePrincipalIdentifier"
    },
    Resource = new ResourceProperty {
        Catalog = catalog,
        Database = new DatabaseResourceProperty {
            CatalogId = "catalogId",
            Name = "name"
        },
        DataCellsFilter = new DataCellsFilterResourceProperty {
            DatabaseName = "databaseName",
            Name = "name",
            TableCatalogId = "tableCatalogId",
            TableName = "tableName"
        },
        DataLocation = new DataLocationResourceProperty {
            CatalogId = "catalogId",
            ResourceArn = "resourceArn"
        },
        LfTag = new LFTagKeyResourceProperty {
            CatalogId = "catalogId",
            TagKey = "tagKey",
            TagValues = new [] { "tagValues" }
        },
        LfTagPolicy = new LFTagPolicyResourceProperty {
            CatalogId = "catalogId",
            Expression = new [] { new LFTagProperty {
                TagKey = "tagKey",
                TagValues = new [] { "tagValues" }
            } },
            ResourceType = "resourceType"
        },
        Table = new TableResourceProperty {
            CatalogId = "catalogId",
            DatabaseName = "databaseName",

            // the properties below are optional
            Name = "name",
            TableWildcard = tableWildcard
        },
        TableWithColumns = new TableWithColumnsResourceProperty {
            CatalogId = "catalogId",
            DatabaseName = "databaseName",
            Name = "name",

            // the properties below are optional
            ColumnNames = new [] { "columnNames" },
            ColumnWildcard = new ColumnWildcardProperty {
                ExcludedColumnNames = new [] { "excludedColumnNames" }
            }
        }
    },

    // the properties below are optional
    Catalog = "catalog"
};
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var catalog interface{}
var tableWildcard interface{}

cfnPrincipalPermissionsProps := &CfnPrincipalPermissionsProps{
	Permissions: []*string{
		jsii.String("permissions"),
	},
	PermissionsWithGrantOption: []*string{
		jsii.String("permissionsWithGrantOption"),
	},
	Principal: &DataLakePrincipalProperty{
		DataLakePrincipalIdentifier: jsii.String("dataLakePrincipalIdentifier"),
	},
	Resource: &ResourceProperty{
		Catalog: catalog,
		Database: &DatabaseResourceProperty{
			CatalogId: jsii.String("catalogId"),
			Name: jsii.String("name"),
		},
		DataCellsFilter: &DataCellsFilterResourceProperty{
			DatabaseName: jsii.String("databaseName"),
			Name: jsii.String("name"),
			TableCatalogId: jsii.String("tableCatalogId"),
			TableName: jsii.String("tableName"),
		},
		DataLocation: &DataLocationResourceProperty{
			CatalogId: jsii.String("catalogId"),
			ResourceArn: jsii.String("resourceArn"),
		},
		LfTag: &LFTagKeyResourceProperty{
			CatalogId: jsii.String("catalogId"),
			TagKey: jsii.String("tagKey"),
			TagValues: []*string{
				jsii.String("tagValues"),
			},
		},
		LfTagPolicy: &LFTagPolicyResourceProperty{
			CatalogId: jsii.String("catalogId"),
			Expression: []interface{}{
				&LFTagProperty{
					TagKey: jsii.String("tagKey"),
					TagValues: []*string{
						jsii.String("tagValues"),
					},
				},
			},
			ResourceType: jsii.String("resourceType"),
		},
		Table: &TableResourceProperty{
			CatalogId: jsii.String("catalogId"),
			DatabaseName: jsii.String("databaseName"),

			// the properties below are optional
			Name: jsii.String("name"),
			TableWildcard: tableWildcard,
		},
		TableWithColumns: &TableWithColumnsResourceProperty{
			CatalogId: jsii.String("catalogId"),
			DatabaseName: jsii.String("databaseName"),
			Name: jsii.String("name"),

			// the properties below are optional
			ColumnNames: []*string{
				jsii.String("columnNames"),
			},
			ColumnWildcard: &ColumnWildcardProperty{
				ExcludedColumnNames: []*string{
					jsii.String("excludedColumnNames"),
				},
			},
		},
	},

	// the properties below are optional
	Catalog: jsii.String("catalog"),
}

Properties ​

catalogoptionalstringcatalogoptionalstrcatalogoptionalStringCatalogoptionalstringCatalogoptional*string #
The identifier for the Data Catalog .

By default, the account ID. The Data Catalog is the persistent metadata store. It contains database definitions, table definitions, and other control information to manage your Lake Formation environment.

permissionsstring[]permissionstyping.List[str]permissionsList<String>Permissionsstring[]Permissions*[]*string required #
The permissions granted or revoked.
permissionsWithGrantOptionstring[]permissions_with_grant_optiontyping.List[str]permissionsWithGrantOptionList<String>PermissionsWithGrantOptionstring[]PermissionsWithGrantOption*[]*string required #
Indicates the ability to grant permissions (as a subset of permissions granted).
principalIResolvable | CfnPrincipalPermissions.DataLakePrincipalPropertyprincipaltyping.Union[IResolvable, DataLakePrincipalProperty]principalIResolvablePrincipalIResolvablePrincipalinterface{} required #
The principal to be granted a permission.
resourceIResolvable | CfnPrincipalPermissions.ResourcePropertyresourcetyping.Union[IResolvable, ResourceProperty]resourceIResolvableResourceIResolvableResourceinterface{} required #
The resource to be granted or revoked permissions.