buildkite.Pipeline.getSignedSteps

import pulumi
import pulumi_buildkite as buildkite
import pulumiverse_buildkite as buildkite

repository = "git@github.com:my-org/my-repo.git"
my_steps = buildkite.Pipeline.get_signed_steps(repository=repository,
    jwks_file="/path/to/my/jwks.json",
    jwks_key_id="my-key",
    unsigned_steps="""steps:
- label: ":pipeline:"
  command: buildkite-agent pipeline upload
""")
my_pipeline = buildkite.pipeline.Pipeline("my-pipeline",
    repository=repository,
    steps=my_steps.steps)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-buildkite/sdk/v3/go/buildkite/Pipeline"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		repository := "git@github.com:my-org/my-repo.git"
		my_steps, err := Pipeline.GetSignedSteps(ctx, &pipeline.GetSignedStepsArgs{
			Repository:    repository,
			JwksFile:      pulumi.StringRef("/path/to/my/jwks.json"),
			JwksKeyId:     pulumi.StringRef("my-key"),
			UnsignedSteps: "steps:\n- label: \":pipeline:\"\n  command: buildkite-agent pipeline upload\n",
		}, nil)
		if err != nil {
			return err
		}
		_, err = Pipeline.NewPipeline(ctx, "my-pipeline", &Pipeline.PipelineArgs{
			Repository: pulumi.String(repository),
			Steps:      *pulumi.String(my_steps.Steps),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Buildkite = Pulumi.Buildkite;
using Buildkite = Pulumiverse.Buildkite;

return await Deployment.RunAsync(() => 
{
    var repository = "git@github.com:my-org/my-repo.git";

    var my_steps = Buildkite.Pipeline.GetSignedSteps.Invoke(new()
    {
        Repository = repository,
        JwksFile = "/path/to/my/jwks.json",
        JwksKeyId = "my-key",
        UnsignedSteps = @"steps:
- label: "":pipeline:""
  command: buildkite-agent pipeline upload
",
    });

    var my_pipeline = new Buildkite.Pipeline.Pipeline("my-pipeline", new()
    {
        Repository = repository,
        Steps = my_steps.Apply(my_steps => my_steps.Apply(getSignedStepsResult => getSignedStepsResult.Steps)),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.buildkite.Pipeline.PipelineFunctions;
import com.pulumi.buildkite.Pipeline.inputs.GetSignedStepsArgs;
import com.pulumi.buildkite.Pipeline.Pipeline;
import com.pulumi.buildkite.Pipeline.PipelineArgs;
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 repository = "git@github.com:my-org/my-repo.git";

        final var my-steps = PipelineFunctions.getSignedSteps(GetSignedStepsArgs.builder()
            .repository(repository)
            .jwksFile("/path/to/my/jwks.json")
            .jwksKeyId("my-key")
            .unsignedSteps("""
steps:
- label: ":pipeline:"
  command: buildkite-agent pipeline upload
            """)
            .build());

        var my_pipeline = new Pipeline("my-pipeline", PipelineArgs.builder()        
            .repository(repository)
            .steps(my_steps.steps())
            .build());

    }
}

resources:
  my-pipeline:
    type: buildkite:Pipeline:Pipeline
    properties:
      repository: ${repository}
      steps: ${["my-steps"].steps}
variables:
  repository: git@github.com:my-org/my-repo.git
  my-steps:
    fn::invoke:
      Function: buildkite:Pipeline:getSignedSteps
      Arguments:
        repository: ${repository}
        jwksFile: /path/to/my/jwks.json
        jwksKeyId: my-key
        unsignedSteps: |
          steps:
          - label: ":pipeline:"
            command: buildkite-agent pipeline upload          

def get_signed_steps(jwks: Optional[str] = None,
                     jwks_file: Optional[str] = None,
                     jwks_key_id: Optional[str] = None,
                     repository: Optional[str] = None,
                     unsigned_steps: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetSignedStepsResult
def get_signed_steps_output(jwks: Optional[pulumi.Input[str]] = None,
                     jwks_file: Optional[pulumi.Input[str]] = None,
                     jwks_key_id: Optional[pulumi.Input[str]] = None,
                     repository: Optional[pulumi.Input[str]] = None,
                     unsigned_steps: Optional[pulumi.Input[str]] = None,
                     opts: Optional[InvokeOptions] = None) -> Output[GetSignedStepsResult]

func GetSignedSteps(ctx *Context, args *GetSignedStepsArgs, opts ...InvokeOption) (*GetSignedStepsResult, error)
func GetSignedStepsOutput(ctx *Context, args *GetSignedStepsOutputArgs, opts ...InvokeOption) GetSignedStepsResultOutput

public static class GetSignedSteps 
{
    public static Task<GetSignedStepsResult> InvokeAsync(GetSignedStepsArgs args, InvokeOptions? opts = null)
    public static Output<GetSignedStepsResult> Invoke(GetSignedStepsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSignedStepsResult> getSignedSteps(GetSignedStepsArgs args, InvokeOptions options)
public static Output<GetSignedStepsResult> getSignedSteps(GetSignedStepsArgs args, InvokeOptions options)

fn::invoke:
  function: buildkite:Pipeline/getSignedSteps:getSignedSteps
  arguments:
    # arguments dictionary