Docs Packages
  1. Packages
  2. GitLab
  3. API Docs
  4. Runner
GitLab v6.11.0 published on Friday, Apr 19, 2024 by Pulumi
pulumi/pulumi-gitlab

gitlab.Runner

Explore with Pulumi AI

gitlab logo
GitLab v6.11.0 published on Friday, Apr 19, 2024 by Pulumi
pulumi/pulumi-gitlab

    The gitlab.Runner resource allows to manage the lifecycle of a runner.

    A runner can either be registered at an instance level or group level. The runner will be registered at a group level if the token used is from a group, or at an instance level if the token used is for the instance.

    ~ > Using this resource will register a runner using the deprecated registration_token flow. To use the new authentication_token flow instead, use the gitlab.UserRunner resource!

    Upstream API: GitLab REST API docs

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as gitlab from "@pulumi/gitlab";
import * as local from "@pulumi/local";

// Basic GitLab Group Runner
const myGroup = new gitlab.Group("myGroup", {description: "group that holds the runners"});
const basicRunner = new gitlab.Runner("basicRunner", {registrationToken: myGroup.runnersToken});
// GitLab Runner that runs only tagged jobs
const taggedOnly = new gitlab.Runner("taggedOnly", {
    registrationToken: myGroup.runnersToken,
    description: "I only run tagged jobs",
    runUntagged: false,
    tagLists: [
        "tag_one",
        "tag_two",
    ],
});
// GitLab Runner that only runs on protected branches
const _protected = new gitlab.Runner("protected", {
    registrationToken: myGroup.runnersToken,
    description: "I only run protected jobs",
    accessLevel: "ref_protected",
});
// Generate a `config.toml` file that you can use to create a runner
// This is the typical workflow for this resource, using it to create an authentication_token which can then be used
// to generate the `config.toml` file to prevent re-registering the runner every time new hardware is created.
const myCustomGroup = new gitlab.Group("myCustomGroup", {description: "group that holds the custom runners"});
const myRunner = new gitlab.Runner("myRunner", {registrationToken: myCustomGroup.runnersToken});
// This creates a configuration for a local "shell" runner, but can be changed to generate whatever is needed.
// Place this configuration file on a server at `/etc/gitlab-runner/config.toml`, then run `gitlab-runner start`.
// See https://docs.gitlab.com/runner/configuration/advanced-configuration.html for more information.
const config = new local.File("config", {
    filename: `${path.module}/config.toml`,
    content: pulumi.interpolate`  concurrent = 1

  [[runners]]
    name = "Hello Terraform"
    url = "https://example.gitlab.com/"
    token = "${myRunner.authenticationToken}"
    executor = "shell"
    
`,
});

    import pulumi
import pulumi_gitlab as gitlab
import pulumi_local as local

# Basic GitLab Group Runner
my_group = gitlab.Group("myGroup", description="group that holds the runners")
basic_runner = gitlab.Runner("basicRunner", registration_token=my_group.runners_token)
# GitLab Runner that runs only tagged jobs
tagged_only = gitlab.Runner("taggedOnly",
    registration_token=my_group.runners_token,
    description="I only run tagged jobs",
    run_untagged=False,
    tag_lists=[
        "tag_one",
        "tag_two",
    ])
# GitLab Runner that only runs on protected branches
protected = gitlab.Runner("protected",
    registration_token=my_group.runners_token,
    description="I only run protected jobs",
    access_level="ref_protected")
# Generate a `config.toml` file that you can use to create a runner
# This is the typical workflow for this resource, using it to create an authentication_token which can then be used
# to generate the `config.toml` file to prevent re-registering the runner every time new hardware is created.
my_custom_group = gitlab.Group("myCustomGroup", description="group that holds the custom runners")
my_runner = gitlab.Runner("myRunner", registration_token=my_custom_group.runners_token)
# This creates a configuration for a local "shell" runner, but can be changed to generate whatever is needed.
# Place this configuration file on a server at `/etc/gitlab-runner/config.toml`, then run `gitlab-runner start`.
# See https://docs.gitlab.com/runner/configuration/advanced-configuration.html for more information.
config = local.File("config",
    filename=f"{path['module']}/config.toml",
    content=my_runner.authentication_token.apply(lambda authentication_token: f"""  concurrent = 1

  [[runners]]
    name = "Hello Terraform"
    url = "https://example.gitlab.com/"
    token = "{authentication_token}"
    executor = "shell"
    
"""))

    package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gitlab/sdk/v6/go/gitlab"
	"github.com/pulumi/pulumi-local/sdk/go/local"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Basic GitLab Group Runner
		myGroup, err := gitlab.NewGroup(ctx, "myGroup", &gitlab.GroupArgs{
			Description: pulumi.String("group that holds the runners"),
		})
		if err != nil {
			return err
		}
		_, err = gitlab.NewRunner(ctx, "basicRunner", &gitlab.RunnerArgs{
			RegistrationToken: myGroup.RunnersToken,
		})
		if err != nil {
			return err
		}
		// GitLab Runner that runs only tagged jobs
		_, err = gitlab.NewRunner(ctx, "taggedOnly", &gitlab.RunnerArgs{
			RegistrationToken: myGroup.RunnersToken,
			Description:       pulumi.String("I only run tagged jobs"),
			RunUntagged:       pulumi.Bool(false),
			TagLists: pulumi.StringArray{
				pulumi.String("tag_one"),
				pulumi.String("tag_two"),
			},
		})
		if err != nil {
			return err
		}
		// GitLab Runner that only runs on protected branches
		_, err = gitlab.NewRunner(ctx, "protected", &gitlab.RunnerArgs{
			RegistrationToken: myGroup.RunnersToken,
			Description:       pulumi.String("I only run protected jobs"),
			AccessLevel:       pulumi.String("ref_protected"),
		})
		if err != nil {
			return err
		}
		myCustomGroup, err := gitlab.NewGroup(ctx, "myCustomGroup", &gitlab.GroupArgs{
			Description: pulumi.String("group that holds the custom runners"),
		})
		if err != nil {
			return err
		}
		myRunner, err := gitlab.NewRunner(ctx, "myRunner", &gitlab.RunnerArgs{
			RegistrationToken: myCustomGroup.RunnersToken,
		})
		if err != nil {
			return err
		}
		// This creates a configuration for a local "shell" runner, but can be changed to generate whatever is needed.
		// Place this configuration file on a server at `/etc/gitlab-runner/config.toml`, then run `gitlab-runner start`.
		// See https://docs.gitlab.com/runner/configuration/advanced-configuration.html for more information.
		_, err = local.NewFile(ctx, "config", &local.FileArgs{
			Filename: pulumi.String(fmt.Sprintf("%v/config.toml", path.Module)),
			Content: myRunner.AuthenticationToken.ApplyT(func(authenticationToken string) (string, error) {
				return fmt.Sprintf(`  concurrent = 1

  [[runners]]
    name = "Hello Terraform"
    url = "https://example.gitlab.com/"
    token = "%v"
    executor = "shell"
    
`, authenticationToken), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using GitLab = Pulumi.GitLab;
using Local = Pulumi.Local;

return await Deployment.RunAsync(() => 
{
    // Basic GitLab Group Runner
    var myGroup = new GitLab.Group("myGroup", new()
    {
        Description = "group that holds the runners",
    });

    var basicRunner = new GitLab.Runner("basicRunner", new()
    {
        RegistrationToken = myGroup.RunnersToken,
    });

    // GitLab Runner that runs only tagged jobs
    var taggedOnly = new GitLab.Runner("taggedOnly", new()
    {
        RegistrationToken = myGroup.RunnersToken,
        Description = "I only run tagged jobs",
        RunUntagged = false,
        TagLists = new[]
        {
            "tag_one",
            "tag_two",
        },
    });

    // GitLab Runner that only runs on protected branches
    var @protected = new GitLab.Runner("protected", new()
    {
        RegistrationToken = myGroup.RunnersToken,
        Description = "I only run protected jobs",
        AccessLevel = "ref_protected",
    });

    // Generate a `config.toml` file that you can use to create a runner
    // This is the typical workflow for this resource, using it to create an authentication_token which can then be used
    // to generate the `config.toml` file to prevent re-registering the runner every time new hardware is created.
    var myCustomGroup = new GitLab.Group("myCustomGroup", new()
    {
        Description = "group that holds the custom runners",
    });

    var myRunner = new GitLab.Runner("myRunner", new()
    {
        RegistrationToken = myCustomGroup.RunnersToken,
    });

    // This creates a configuration for a local "shell" runner, but can be changed to generate whatever is needed.
    // Place this configuration file on a server at `/etc/gitlab-runner/config.toml`, then run `gitlab-runner start`.
    // See https://docs.gitlab.com/runner/configuration/advanced-configuration.html for more information.
    var config = new Local.File("config", new()
    {
        Filename = $"{path.Module}/config.toml",
        Content = myRunner.AuthenticationToken.Apply(authenticationToken => @$"  concurrent = 1

  [[runners]]
    name = ""Hello Terraform""
    url = ""https://example.gitlab.com/""
    token = ""{authenticationToken}""
    executor = ""shell""
    
"),
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gitlab.Group;
import com.pulumi.gitlab.GroupArgs;
import com.pulumi.gitlab.Runner;
import com.pulumi.gitlab.RunnerArgs;
import com.pulumi.local.File;
import com.pulumi.local.FileArgs;
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) {
        // Basic GitLab Group Runner
        var myGroup = new Group("myGroup", GroupArgs.builder()        
            .description("group that holds the runners")
            .build());

        var basicRunner = new Runner("basicRunner", RunnerArgs.builder()        
            .registrationToken(myGroup.runnersToken())
            .build());

        // GitLab Runner that runs only tagged jobs
        var taggedOnly = new Runner("taggedOnly", RunnerArgs.builder()        
            .registrationToken(myGroup.runnersToken())
            .description("I only run tagged jobs")
            .runUntagged("false")
            .tagLists(            
                "tag_one",
                "tag_two")
            .build());

        // GitLab Runner that only runs on protected branches
        var protected_ = new Runner("protected", RunnerArgs.builder()        
            .registrationToken(myGroup.runnersToken())
            .description("I only run protected jobs")
            .accessLevel("ref_protected")
            .build());

        // Generate a `config.toml` file that you can use to create a runner
        // This is the typical workflow for this resource, using it to create an authentication_token which can then be used
        // to generate the `config.toml` file to prevent re-registering the runner every time new hardware is created.
        var myCustomGroup = new Group("myCustomGroup", GroupArgs.builder()        
            .description("group that holds the custom runners")
            .build());

        var myRunner = new Runner("myRunner", RunnerArgs.builder()        
            .registrationToken(myCustomGroup.runnersToken())
            .build());

        // This creates a configuration for a local "shell" runner, but can be changed to generate whatever is needed.
        // Place this configuration file on a server at `/etc/gitlab-runner/config.toml`, then run `gitlab-runner start`.
        // See https://docs.gitlab.com/runner/configuration/advanced-configuration.html for more information.
        var config = new File("config", FileArgs.builder()        
            .filename(String.format("%s/config.toml", path.module()))
            .content(myRunner.authenticationToken().applyValue(authenticationToken -> """
  concurrent = 1

  [[runners]]
    name = "Hello Terraform"
    url = "https://example.gitlab.com/"
    token = "%s"
    executor = "shell"
    
", authenticationToken)))
            .build());

    }
}

    resources:
  # Basic GitLab Group Runner
  myGroup:
    type: gitlab:Group
    properties:
      description: group that holds the runners
  basicRunner:
    type: gitlab:Runner
    properties:
      registrationToken: ${myGroup.runnersToken}
  # GitLab Runner that runs only tagged jobs
  taggedOnly:
    type: gitlab:Runner
    properties:
      registrationToken: ${myGroup.runnersToken}
      description: I only run tagged jobs
      runUntagged: 'false'
      tagLists:
        - tag_one
        - tag_two
  # GitLab Runner that only runs on protected branches
  protected: # Generate a `config.toml` file that you can use to create a runner
  # This is the typical workflow for this resource, using it to create an authentication_token which can then be used
  # to generate the `config.toml` file to prevent re-registering the runner every time new hardware is created.
    type: gitlab:Runner
    properties:
      registrationToken: ${myGroup.runnersToken}
      description: I only run protected jobs
      accessLevel: ref_protected
  myCustomGroup:
    type: gitlab:Group
    properties:
      description: group that holds the custom runners
  myRunner:
    type: gitlab:Runner
    properties:
      registrationToken: ${myCustomGroup.runnersToken}
  # This creates a configuration for a local "shell" runner, but can be changed to generate whatever is needed.
  # Place this configuration file on a server at `/etc/gitlab-runner/config.toml`, then run `gitlab-runner start`.
  # See https://docs.gitlab.com/runner/configuration/advanced-configuration.html for more information.
  config:
    type: local:File
    properties:
      filename: ${path.module}/config.toml
      content: "  concurrent = 1\n\n  [[runners]]\n    name = \"Hello Terraform\"\n    url = \"https://example.gitlab.com/\"\n    token = \"${myRunner.authenticationToken}\"\n    executor = \"shell\"\n    \n"

    Create Runner Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new Runner(name: string, args: RunnerArgs, opts?: CustomResourceOptions);
    @overload
def Runner(resource_name: str,
           args: RunnerArgs,
           opts: Optional[ResourceOptions] = None)

@overload
def Runner(resource_name: str,
           opts: Optional[ResourceOptions] = None,
           registration_token: Optional[str] = None,
           access_level: Optional[str] = None,
           description: Optional[str] = None,
           locked: Optional[bool] = None,
           maximum_timeout: Optional[int] = None,
           paused: Optional[bool] = None,
           run_untagged: Optional[bool] = None,
           tag_lists: Optional[Sequence[str]] = None)
    func NewRunner(ctx *Context, name string, args RunnerArgs, opts ...ResourceOption) (*Runner, error)
    public Runner(string name, RunnerArgs args, CustomResourceOptions? opts = null)
    public Runner(String name, RunnerArgs args)
public Runner(String name, RunnerArgs args, CustomResourceOptions options)

    type: gitlab:Runner
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args RunnerArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args RunnerArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args RunnerArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RunnerArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args RunnerArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var runnerResource = new GitLab.Runner("runnerResource", new()
{
    RegistrationToken = "string",
    AccessLevel = "string",
    Description = "string",
    Locked = false,
    MaximumTimeout = 0,
    Paused = false,
    RunUntagged = false,
    TagLists = new[]
    {
        "string",
    },
});

    example, err := gitlab.NewRunner(ctx, "runnerResource", &gitlab.RunnerArgs{
	RegistrationToken: pulumi.String("string"),
	AccessLevel:       pulumi.String("string"),
	Description:       pulumi.String("string"),
	Locked:            pulumi.Bool(false),
	MaximumTimeout:    pulumi.Int(0),
	Paused:            pulumi.Bool(false),
	RunUntagged:       pulumi.Bool(false),
	TagLists: pulumi.StringArray{
		pulumi.String("string"),
	},
})

    var runnerResource = new Runner("runnerResource", RunnerArgs.builder()        
    .registrationToken("string")
    .accessLevel("string")
    .description("string")
    .locked(false)
    .maximumTimeout(0)
    .paused(false)
    .runUntagged(false)
    .tagLists("string")
    .build());

    runner_resource = gitlab.Runner("runnerResource",
    registration_token="string",
    access_level="string",
    description="string",
    locked=False,
    maximum_timeout=0,
    paused=False,
    run_untagged=False,
    tag_lists=["string"])

    const runnerResource = new gitlab.Runner("runnerResource", {
    registrationToken: "string",
    accessLevel: "string",
    description: "string",
    locked: false,
    maximumTimeout: 0,
    paused: false,
    runUntagged: false,
    tagLists: ["string"],
});

    type: gitlab:Runner
properties:
    accessLevel: string
    description: string
    locked: false
    maximumTimeout: 0
    paused: false
    registrationToken: string
    runUntagged: false
    tagLists:
        - string

    Runner Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The Runner resource accepts the following input properties:

    RegistrationToken string
    The registration token used to register the runner.
    AccessLevel string
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    Description string
    The runner's description.
    Locked bool
    Whether the runner should be locked for current project.
    MaximumTimeout int
    Maximum timeout set when this runner handles the job.
    Paused bool
    Whether the runner should ignore new jobs.
    RunUntagged bool
    Whether the runner should handle untagged jobs.
    TagLists List<string>
    List of runner’s tags.
    RegistrationToken string
    The registration token used to register the runner.
    AccessLevel string
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    Description string
    The runner's description.
    Locked bool
    Whether the runner should be locked for current project.
    MaximumTimeout int
    Maximum timeout set when this runner handles the job.
    Paused bool
    Whether the runner should ignore new jobs.
    RunUntagged bool
    Whether the runner should handle untagged jobs.
    TagLists []string
    List of runner’s tags.
    registrationToken String
    The registration token used to register the runner.
    accessLevel String
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    description String
    The runner's description.
    locked Boolean
    Whether the runner should be locked for current project.
    maximumTimeout Integer
    Maximum timeout set when this runner handles the job.
    paused Boolean
    Whether the runner should ignore new jobs.
    runUntagged Boolean
    Whether the runner should handle untagged jobs.
    tagLists List<String>
    List of runner’s tags.
    registrationToken string
    The registration token used to register the runner.
    accessLevel string
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    description string
    The runner's description.
    locked boolean
    Whether the runner should be locked for current project.
    maximumTimeout number
    Maximum timeout set when this runner handles the job.
    paused boolean
    Whether the runner should ignore new jobs.
    runUntagged boolean
    Whether the runner should handle untagged jobs.
    tagLists string[]
    List of runner’s tags.
    registration_token str
    The registration token used to register the runner.
    access_level str
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    description str
    The runner's description.
    locked bool
    Whether the runner should be locked for current project.
    maximum_timeout int
    Maximum timeout set when this runner handles the job.
    paused bool
    Whether the runner should ignore new jobs.
    run_untagged bool
    Whether the runner should handle untagged jobs.
    tag_lists Sequence[str]
    List of runner’s tags.
    registrationToken String
    The registration token used to register the runner.
    accessLevel String
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    description String
    The runner's description.
    locked Boolean
    Whether the runner should be locked for current project.
    maximumTimeout Number
    Maximum timeout set when this runner handles the job.
    paused Boolean
    Whether the runner should ignore new jobs.
    runUntagged Boolean
    Whether the runner should handle untagged jobs.
    tagLists List<String>
    List of runner’s tags.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Runner resource produces the following output properties:

    AuthenticationToken string
    The authentication token used for building a config.toml file. This value is not present when imported.
    Id string
    The provider-assigned unique ID for this managed resource.
    Status string
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    AuthenticationToken string
    The authentication token used for building a config.toml file. This value is not present when imported.
    Id string
    The provider-assigned unique ID for this managed resource.
    Status string
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    authenticationToken String
    The authentication token used for building a config.toml file. This value is not present when imported.
    id String
    The provider-assigned unique ID for this managed resource.
    status String
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    authenticationToken string
    The authentication token used for building a config.toml file. This value is not present when imported.
    id string
    The provider-assigned unique ID for this managed resource.
    status string
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    authentication_token str
    The authentication token used for building a config.toml file. This value is not present when imported.
    id str
    The provider-assigned unique ID for this managed resource.
    status str
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    authenticationToken String
    The authentication token used for building a config.toml file. This value is not present when imported.
    id String
    The provider-assigned unique ID for this managed resource.
    status String
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.

    Look up Existing Runner Resource

    Get an existing Runner resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: RunnerState, opts?: CustomResourceOptions): Runner
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        access_level: Optional[str] = None,
        authentication_token: Optional[str] = None,
        description: Optional[str] = None,
        locked: Optional[bool] = None,
        maximum_timeout: Optional[int] = None,
        paused: Optional[bool] = None,
        registration_token: Optional[str] = None,
        run_untagged: Optional[bool] = None,
        status: Optional[str] = None,
        tag_lists: Optional[Sequence[str]] = None) -> Runner
    func GetRunner(ctx *Context, name string, id IDInput, state *RunnerState, opts ...ResourceOption) (*Runner, error)
    public static Runner Get(string name, Input<string> id, RunnerState? state, CustomResourceOptions? opts = null)
    public static Runner get(String name, Output<String> id, RunnerState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    AccessLevel string
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    AuthenticationToken string
    The authentication token used for building a config.toml file. This value is not present when imported.
    Description string
    The runner's description.
    Locked bool
    Whether the runner should be locked for current project.
    MaximumTimeout int
    Maximum timeout set when this runner handles the job.
    Paused bool
    Whether the runner should ignore new jobs.
    RegistrationToken string
    The registration token used to register the runner.
    RunUntagged bool
    Whether the runner should handle untagged jobs.
    Status string
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    TagLists List<string>
    List of runner’s tags.
    AccessLevel string
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    AuthenticationToken string
    The authentication token used for building a config.toml file. This value is not present when imported.
    Description string
    The runner's description.
    Locked bool
    Whether the runner should be locked for current project.
    MaximumTimeout int
    Maximum timeout set when this runner handles the job.
    Paused bool
    Whether the runner should ignore new jobs.
    RegistrationToken string
    The registration token used to register the runner.
    RunUntagged bool
    Whether the runner should handle untagged jobs.
    Status string
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    TagLists []string
    List of runner’s tags.
    accessLevel String
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    authenticationToken String
    The authentication token used for building a config.toml file. This value is not present when imported.
    description String
    The runner's description.
    locked Boolean
    Whether the runner should be locked for current project.
    maximumTimeout Integer
    Maximum timeout set when this runner handles the job.
    paused Boolean
    Whether the runner should ignore new jobs.
    registrationToken String
    The registration token used to register the runner.
    runUntagged Boolean
    Whether the runner should handle untagged jobs.
    status String
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    tagLists List<String>
    List of runner’s tags.
    accessLevel string
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    authenticationToken string
    The authentication token used for building a config.toml file. This value is not present when imported.
    description string
    The runner's description.
    locked boolean
    Whether the runner should be locked for current project.
    maximumTimeout number
    Maximum timeout set when this runner handles the job.
    paused boolean
    Whether the runner should ignore new jobs.
    registrationToken string
    The registration token used to register the runner.
    runUntagged boolean
    Whether the runner should handle untagged jobs.
    status string
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    tagLists string[]
    List of runner’s tags.
    access_level str
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    authentication_token str
    The authentication token used for building a config.toml file. This value is not present when imported.
    description str
    The runner's description.
    locked bool
    Whether the runner should be locked for current project.
    maximum_timeout int
    Maximum timeout set when this runner handles the job.
    paused bool
    Whether the runner should ignore new jobs.
    registration_token str
    The registration token used to register the runner.
    run_untagged bool
    Whether the runner should handle untagged jobs.
    status str
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    tag_lists Sequence[str]
    List of runner’s tags.
    accessLevel String
    The access_level of the runner. Valid values are: not_protected, ref_protected.
    authenticationToken String
    The authentication token used for building a config.toml file. This value is not present when imported.
    description String
    The runner's description.
    locked Boolean
    Whether the runner should be locked for current project.
    maximumTimeout Number
    Maximum timeout set when this runner handles the job.
    paused Boolean
    Whether the runner should ignore new jobs.
    registrationToken String
    The registration token used to register the runner.
    runUntagged Boolean
    Whether the runner should handle untagged jobs.
    status String
    The status of runners to show, one of: online and offline. active and paused are also possible values which were deprecated in GitLab 14.8 and will be removed in GitLab 16.0.
    tagLists List<String>
    List of runner’s tags.

    Import

    A GitLab Runner can be imported using the runner’s ID, eg

    $ pulumi import gitlab:index/runner:Runner this 1

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    GitLab pulumi/pulumi-gitlab
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the gitlab Terraform Provider.
    gitlab logo
    GitLab v6.11.0 published on Friday, Apr 19, 2024 by Pulumi
    pulumi/pulumi-gitlab