databricks.getAwsBucketPolicy

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketV2;
import com.pulumi.aws.s3.BucketV2Args;
import com.pulumi.databricks.DatabricksFunctions;
import com.pulumi.databricks.inputs.GetAwsBucketPolicyArgs;
import com.pulumi.aws.s3.BucketPolicy;
import com.pulumi.aws.s3.BucketPolicyArgs;
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 this_ = new BucketV2("this", BucketV2Args.builder()        
            .bucket("<unique_bucket_name>")
            .acl("private")
            .forceDestroy(true)
            .build());

        final var stuff = DatabricksFunctions.getAwsBucketPolicy(GetAwsBucketPolicyArgs.builder()
            .bucketName(this_.bucket())
            .build());

        var thisBucketPolicy = new BucketPolicy("thisBucketPolicy", BucketPolicyArgs.builder()        
            .bucket(this_.id())
            .policy(thisDatabricksAwsBucketPolicy.json())
            .build());

    }
}

resources:
  this:
    type: aws:s3:BucketV2
    properties:
      bucket: <unique_bucket_name>
      acl: private
      forceDestroy: true
  thisBucketPolicy:
    type: aws:s3:BucketPolicy
    name: this
    properties:
      bucket: ${this.id}
      policy: ${thisDatabricksAwsBucketPolicy.json}
variables:
  stuff:
    fn::invoke:
      Function: databricks:getAwsBucketPolicy
      Arguments:
        bucketName: ${this.bucket}

function getAwsBucketPolicy(args: GetAwsBucketPolicyArgs, opts?: InvokeOptions): Promise<GetAwsBucketPolicyResult>
function getAwsBucketPolicyOutput(args: GetAwsBucketPolicyOutputArgs, opts?: InvokeOptions): Output<GetAwsBucketPolicyResult>

def get_aws_bucket_policy(bucket: Optional[str] = None,
                          databricks_account_id: Optional[str] = None,
                          databricks_e2_account_id: Optional[str] = None,
                          full_access_role: Optional[str] = None,
                          opts: Optional[InvokeOptions] = None) -> GetAwsBucketPolicyResult
def get_aws_bucket_policy_output(bucket: Optional[pulumi.Input[str]] = None,
                          databricks_account_id: Optional[pulumi.Input[str]] = None,
                          databricks_e2_account_id: Optional[pulumi.Input[str]] = None,
                          full_access_role: Optional[pulumi.Input[str]] = None,
                          opts: Optional[InvokeOptions] = None) -> Output[GetAwsBucketPolicyResult]

func GetAwsBucketPolicy(ctx *Context, args *GetAwsBucketPolicyArgs, opts ...InvokeOption) (*GetAwsBucketPolicyResult, error)
func GetAwsBucketPolicyOutput(ctx *Context, args *GetAwsBucketPolicyOutputArgs, opts ...InvokeOption) GetAwsBucketPolicyResultOutput

public static class GetAwsBucketPolicy 
{
    public static Task<GetAwsBucketPolicyResult> InvokeAsync(GetAwsBucketPolicyArgs args, InvokeOptions? opts = null)
    public static Output<GetAwsBucketPolicyResult> Invoke(GetAwsBucketPolicyInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAwsBucketPolicyResult> getAwsBucketPolicy(GetAwsBucketPolicyArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: databricks:index/getAwsBucketPolicy:getAwsBucketPolicy
  arguments:
    # arguments dictionary