getPermissions function

Future<GetPermissionsResult> getPermissions(
  1. GetPermissionsArgs args, {
  2. InvokeOptions? options,
})

Get permissions for a principal to access metadata in the Data Catalog and data organized in underlying data storage such as Amazon S3. Permissions are granted to a principal, in a Data Catalog, relative to a Lake Formation resource, which includes the Data Catalog, databases, tables, LF-tags, and LF-tag policies. For more information, see Security and Access Control to Metadata and Data in Lake Formation.

> NOTE: This data source deals with explicitly granted permissions. Lake Formation grants implicit permissions to data lake administrators, database creators, and table creators. For more information, see Implicit Lake Formation Permissions.

Example Usage

Permissions For A Lake Formation S3 Resource

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

const test = aws.lakeformation.getPermissions({
    dataLocation: {
        arn: testAwsLakeformationResource.arn,
    },
    principal: workflowRole.arn,
});
import pulumi
import pulumi_aws as aws

test = aws.lakeformation.get_permissions(data_location={
        "arn": test_aws_lakeformation_resource["arn"],
    },
    principal=workflow_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var test = Aws.LakeFormation.GetPermissions.Invoke(new()
    {
        DataLocation = new Aws.LakeFormation.Inputs.GetPermissionsDataLocationInputArgs
        {
            Arn = testAwsLakeformationResource.Arn,
        },
        Principal = workflowRole.Arn,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lakeformation"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lakeformation.LookupPermissions(ctx, &lakeformation.LookupPermissionsArgs{
			DataLocation: lakeformation.GetPermissionsDataLocation{
				Arn: testAwsLakeformationResource.Arn,
			},
			Principal: workflowRole.Arn,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lakeformation_getpermissions" "test" {
  data_location = {
    arn = testAwsLakeformationResource.arn
  }
  principal = workflowRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lakeformation.LakeformationFunctions;
import com.pulumi.aws.lakeformation.inputs.GetPermissionsArgs;
import com.pulumi.aws.lakeformation.inputs.GetPermissionsDataLocationArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 test = LakeformationFunctions.getPermissions(GetPermissionsArgs.builder()
            .dataLocation(GetPermissionsDataLocationArgs.builder()
                .arn(testAwsLakeformationResource.arn())
                .build())
            .principal(workflowRole.arn())
            .build());

    }
}
variables:
  test:
    fn::invoke:
      function: aws:lakeformation:getPermissions
      arguments:
        dataLocation:
          arn: ${testAwsLakeformationResource.arn}
        principal: ${workflowRole.arn}

Permissions For A Glue Catalog Database

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

const test = aws.lakeformation.getPermissions({
    database: {
        name: testAwsGlueCatalogDatabase.name,
        catalogId: "110376042874",
    },
    principal: workflowRole.arn,
});
import pulumi
import pulumi_aws as aws

test = aws.lakeformation.get_permissions(database={
        "name": test_aws_glue_catalog_database["name"],
        "catalog_id": "110376042874",
    },
    principal=workflow_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var test = Aws.LakeFormation.GetPermissions.Invoke(new()
    {
        Database = new Aws.LakeFormation.Inputs.GetPermissionsDatabaseInputArgs
        {
            Name = testAwsGlueCatalogDatabase.Name,
            CatalogId = "110376042874",
        },
        Principal = workflowRole.Arn,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lakeformation"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lakeformation.LookupPermissions(ctx, &lakeformation.LookupPermissionsArgs{
			Database: lakeformation.GetPermissionsDatabase{
				Name:      testAwsGlueCatalogDatabase.Name,
				CatalogId: "110376042874",
			},
			Principal: workflowRole.Arn,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lakeformation_getpermissions" "test" {
  database = {
    name       = testAwsGlueCatalogDatabase.name
    catalog_id = "110376042874"
  }
  principal = workflowRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lakeformation.LakeformationFunctions;
import com.pulumi.aws.lakeformation.inputs.GetPermissionsArgs;
import com.pulumi.aws.lakeformation.inputs.GetPermissionsDatabaseArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 test = LakeformationFunctions.getPermissions(GetPermissionsArgs.builder()
            .database(GetPermissionsDatabaseArgs.builder()
                .name(testAwsGlueCatalogDatabase.name())
                .catalogId("110376042874")
                .build())
            .principal(workflowRole.arn())
            .build());

    }
}
variables:
  test:
    fn::invoke:
      function: aws:lakeformation:getPermissions
      arguments:
        database:
          name: ${testAwsGlueCatalogDatabase.name}
          catalogId: '110376042874'
        principal: ${workflowRole.arn}

Permissions For Tag-Based Access Control

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

const test = aws.lakeformation.getPermissions({
    lfTagPolicy: {
        expressions: [
            {
                key: "Team",
                values: ["Sales"],
            },
            {
                key: "Environment",
                values: [
                    "Dev",
                    "Production",
                ],
            },
        ],
        resourceType: "DATABASE",
    },
    principal: workflowRole.arn,
});
import pulumi
import pulumi_aws as aws

test = aws.lakeformation.get_permissions(lf_tag_policy={
        "expressions": [
            {
                "key": "Team",
                "values": ["Sales"],
            },
            {
                "key": "Environment",
                "values": [
                    "Dev",
                    "Production",
                ],
            },
        ],
        "resource_type": "DATABASE",
    },
    principal=workflow_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var test = Aws.LakeFormation.GetPermissions.Invoke(new()
    {
        LfTagPolicy = new Aws.LakeFormation.Inputs.GetPermissionsLfTagPolicyInputArgs
        {
            Expressions = new[]
            {
                new Aws.LakeFormation.Inputs.GetPermissionsLfTagPolicyExpressionInputArgs
                {
                    Key = "Team",
                    Values = new[]
                    {
                        "Sales",
                    },
                },
                new Aws.LakeFormation.Inputs.GetPermissionsLfTagPolicyExpressionInputArgs
                {
                    Key = "Environment",
                    Values = new[]
                    {
                        "Dev",
                        "Production",
                    },
                },
            },
            ResourceType = "DATABASE",
        },
        Principal = workflowRole.Arn,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lakeformation"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lakeformation.LookupPermissions(ctx, &lakeformation.LookupPermissionsArgs{
			LfTagPolicy: lakeformation.GetPermissionsLfTagPolicy{
				Expressions: []lakeformation.GetPermissionsLfTagPolicyExpression{
					{
						Key: "Team",
						Values: []string{
							"Sales",
						},
					},
					{
						Key: "Environment",
						Values: []string{
							"Dev",
							"Production",
						},
					},
				},
				ResourceType: "DATABASE",
			},
			Principal: workflowRole.Arn,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lakeformation_getpermissions" "test" {
  lf_tag_policy = {
    expressions = [{
      "key"    = "Team"
      "values" = ["Sales"]
      }, {
      "key"    = "Environment"
      "values" = ["Dev", "Production"]
    }]
    resource_type = "DATABASE"
  }
  principal = workflowRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lakeformation.LakeformationFunctions;
import com.pulumi.aws.lakeformation.inputs.GetPermissionsArgs;
import com.pulumi.aws.lakeformation.inputs.GetPermissionsLfTagPolicyArgs;
import com.pulumi.aws.lakeformation.inputs.GetPermissionsLfTagPolicyExpressionArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 test = LakeformationFunctions.getPermissions(GetPermissionsArgs.builder()
            .lfTagPolicy(GetPermissionsLfTagPolicyArgs.builder()
                .expressions(
                    GetPermissionsLfTagPolicyExpressionArgs.builder()
                        .key("Team")
                        .values("Sales")
                        .build(),
                    GetPermissionsLfTagPolicyExpressionArgs.builder()
                        .key("Environment")
                        .values(
                            "Dev",
                            "Production")
                        .build())
                .resourceType("DATABASE")
                .build())
            .principal(workflowRole.arn())
            .build());

    }
}
variables:
  test:
    fn::invoke:
      function: aws:lakeformation:getPermissions
      arguments:
        lfTagPolicy:
          expressions:
            - key: Team
              values:
                - Sales
            - key: Environment
              values:
                - Dev
                - Production
          resourceType: DATABASE
        principal: ${workflowRole.arn}

args Arguments passed to this invoke. Arguments for getPermissions. options Invoke options controlling this call.

Implementation

Future<GetPermissionsResult> getPermissions(
  GetPermissionsArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'aws:lakeformation/getPermissions:getPermissions',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetPermissionsResult.fromMap(result);
}