databricks.getJobs
Explore with Pulumi AI
Related Resources
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:
Package Details
- Repository
- databricks pulumi/pulumi-databricks
- License
- Apache-2.0
- Notes
This Pulumi package is based on the
databricks
Terraform Provider.