1. Packages
  2. Databricks
  3. API Docs
  4. getJobs
Databricks v1.26.0 published on Tuesday, Oct 31, 2023 by Pulumi

databricks.getJobs

Explore with Pulumi AI

databricks logo
Databricks v1.26.0 published on Tuesday, Oct 31, 2023 by Pulumi

    The following resources are used in the same context:

    • databricks.Job to manage Databricks Jobs to run non-interactive code in a databricks_cluster.

    Example Usage

    Granting view databricks.Permissions to all databricks.Job within the workspace

    using System.Collections.Generic;
    using System.Linq;
    using System.Threading.Tasks;
    using Pulumi;
    using Databricks = Pulumi.Databricks;
    
    return await Deployment.RunAsync(async() => 
    {
        var @this = await Databricks.GetJobs.InvokeAsync();
    
        var everyoneCanViewAllJobs = new List<Databricks.Permissions>();
        foreach (var range in )
        {
            everyoneCanViewAllJobs.Add(new Databricks.Permissions($"everyoneCanViewAllJobs-{range.Key}", new()
            {
                JobId = range.Value,
                AccessControls = new[]
                {
                    new Databricks.Inputs.PermissionsAccessControlArgs
                    {
                        GroupName = "users",
                        PermissionLevel = "CAN_VIEW",
                    },
                },
            }));
        }
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		this, err := databricks.GetJobs(ctx, nil, nil)
    		if err != nil {
    			return err
    		}
    		var everyoneCanViewAllJobs []*databricks.Permissions
    		for key0, val0 := range this.Ids {
    			__res, err := databricks.NewPermissions(ctx, fmt.Sprintf("everyoneCanViewAllJobs-%v", key0), &databricks.PermissionsArgs{
    				JobId: pulumi.Any(val0),
    				AccessControls: databricks.PermissionsAccessControlArray{
    					&databricks.PermissionsAccessControlArgs{
    						GroupName:       pulumi.String("users"),
    						PermissionLevel: pulumi.String("CAN_VIEW"),
    					},
    				},
    			})
    			if err != nil {
    				return err
    			}
    			everyoneCanViewAllJobs = append(everyoneCanViewAllJobs, __res)
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.databricks.DatabricksFunctions;
    import com.pulumi.databricks.inputs.GetJobsArgs;
    import com.pulumi.databricks.Permissions;
    import com.pulumi.databricks.PermissionsArgs;
    import com.pulumi.databricks.inputs.PermissionsAccessControlArgs;
    import com.pulumi.codegen.internal.KeyedValue;
    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 this = DatabricksFunctions.getJobs();
    
            final var everyoneCanViewAllJobs = this.applyValue(getJobsResult -> {
                final var resources = new ArrayList<Permissions>();
                for (var range : KeyedValue.of(getJobsResult.ids()) {
                    var resource = new Permissions("everyoneCanViewAllJobs-" + range.key(), PermissionsArgs.builder()                
                        .jobId(range.value())
                        .accessControls(PermissionsAccessControlArgs.builder()
                            .groupName("users")
                            .permissionLevel("CAN_VIEW")
                            .build())
                        .build());
    
                    resources.add(resource);
                }
    
                return resources;
            });
    
        }
    }
    
    import pulumi
    import pulumi_databricks as databricks
    
    this = databricks.get_jobs()
    everyone_can_view_all_jobs = []
    for range in [{"key": k, "value": v} for [k, v] in enumerate(this.ids)]:
        everyone_can_view_all_jobs.append(databricks.Permissions(f"everyoneCanViewAllJobs-{range['key']}",
            job_id=range["value"],
            access_controls=[databricks.PermissionsAccessControlArgs(
                group_name="users",
                permission_level="CAN_VIEW",
            )]))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as databricks from "@pulumi/databricks";
    
    export = async () => {
        const this = await databricks.getJobs({});
        const everyoneCanViewAllJobs: databricks.Permissions[] = [];
        for (const range of Object.entries(_this.ids).map(([k, v]) => ({key: k, value: v}))) {
            everyoneCanViewAllJobs.push(new databricks.Permissions(`everyoneCanViewAllJobs-${range.key}`, {
                jobId: range.value,
                accessControls: [{
                    groupName: "users",
                    permissionLevel: "CAN_VIEW",
                }],
            }));
        }
    }
    
    resources:
      everyoneCanViewAllJobs:
        type: databricks:Permissions
        properties:
          jobId: ${range.value}
          accessControls:
            - groupName: users
              permissionLevel: CAN_VIEW
        options: {}
    variables:
      this:
        fn::invoke:
          Function: databricks:getJobs
          Arguments: {}
    

    Getting ID of specific databricks.Job by name

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Databricks = Pulumi.Databricks;
    
    return await Deployment.RunAsync(() => 
    {
        var @this = Databricks.GetJobs.Invoke();
    
        return new Dictionary<string, object?>
        {
            ["x"] = 
            {
                { "sensitive", false },
                { "value", @this.Apply(@this => $"ID of `x` job is {@this.Apply(getJobsResult => getJobsResult.Ids?.X)}") },
            },
        };
    });
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		this, err := databricks.GetJobs(ctx, nil, nil)
    		if err != nil {
    			return err
    		}
    		ctx.Export("x", map[string]interface{}{
    			"sensitive": false,
    			"value":     fmt.Sprintf("ID of `x` job is %v", this.Ids.X),
    		})
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.databricks.DatabricksFunctions;
    import com.pulumi.databricks.inputs.GetJobsArgs;
    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 this = DatabricksFunctions.getJobs();
    
            ctx.export("x", %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference));
        }
    }
    
    import pulumi
    import pulumi_databricks as databricks
    
    this = databricks.get_jobs()
    pulumi.export("x", {
        "sensitive": False,
        "value": f"ID of `x` job is {this.ids['x']}",
    })
    
    import * as pulumi from "@pulumi/pulumi";
    import * as databricks from "@pulumi/databricks";
    
    const this = databricks.getJobs({});
    export const x = {
        sensitive: false,
        value: _this.then(_this => `ID of `x` job is ${_this.ids?.x}`),
    };
    
    variables:
      this:
        fn::invoke:
          Function: databricks:getJobs
          Arguments: {}
    outputs:
      x:
        sensitive: false
        value: ID of `x` job is ${this.ids.x}
    

    Using getJobs

    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 getJobs(args: GetJobsArgs, opts?: InvokeOptions): Promise<GetJobsResult>
    function getJobsOutput(args: GetJobsOutputArgs, opts?: InvokeOptions): Output<GetJobsResult>
    def get_jobs(ids: Optional[Mapping[str, Any]] = None,
                 opts: Optional[InvokeOptions] = None) -> GetJobsResult
    def get_jobs_output(ids: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 opts: Optional[InvokeOptions] = None) -> Output[GetJobsResult]
    func GetJobs(ctx *Context, args *GetJobsArgs, opts ...InvokeOption) (*GetJobsResult, error)
    func GetJobsOutput(ctx *Context, args *GetJobsOutputArgs, opts ...InvokeOption) GetJobsResultOutput

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

    public static class GetJobs 
    {
        public static Task<GetJobsResult> InvokeAsync(GetJobsArgs args, InvokeOptions? opts = null)
        public static Output<GetJobsResult> Invoke(GetJobsInvokeArgs args, InvokeOptions? opts = null)
    }
    public static CompletableFuture<GetJobsResult> getJobs(GetJobsArgs args, InvokeOptions options)
    // Output-based functions aren't available in Java yet
    
    fn::invoke:
      function: databricks:index/getJobs:getJobs
      arguments:
        # arguments dictionary

    The following arguments are supported:

    Ids Dictionary<string, object>

    map of databricks.Job names to ids

    Ids map[string]interface{}

    map of databricks.Job names to ids

    ids Map<String,Object>

    map of databricks.Job names to ids

    ids {[key: string]: any}

    map of databricks.Job names to ids

    ids Mapping[str, Any]

    map of databricks.Job names to ids

    ids Map<Any>

    map of databricks.Job names to ids

    getJobs Result

    The following output properties are available:

    Id string

    The provider-assigned unique ID for this managed resource.

    Ids Dictionary<string, object>

    map of databricks.Job names to ids

    Id string

    The provider-assigned unique ID for this managed resource.

    Ids map[string]interface{}

    map of databricks.Job names to ids

    id String

    The provider-assigned unique ID for this managed resource.

    ids Map<String,Object>

    map of databricks.Job names to ids

    id string

    The provider-assigned unique ID for this managed resource.

    ids {[key: string]: any}

    map of databricks.Job names to ids

    id str

    The provider-assigned unique ID for this managed resource.

    ids Mapping[str, Any]

    map of databricks.Job names to ids

    id String

    The provider-assigned unique ID for this managed resource.

    ids Map<Any>

    map of databricks.Job names to ids

    Package Details

    Repository
    databricks pulumi/pulumi-databricks
    License
    Apache-2.0
    Notes

    This Pulumi package is based on the databricks Terraform Provider.

    databricks logo
    Databricks v1.26.0 published on Tuesday, Oct 31, 2023 by Pulumi