pulumi-gitlab-kotlin/com.pulumi.gitlab.kotlin/UserRunnerArgs

UserRunnerArgs

data class UserRunnerArgs(val accessLevel: Output<String>? = null, val description: Output<String>? = null, val groupId: Output<Int>? = null, val locked: Output<Boolean>? = null, val maintenanceNote: Output<String>? = null, val maximumTimeout: Output<Int>? = null, val paused: Output<Boolean>? = null, val projectId: Output<Int>? = null, val runnerType: Output<String>? = null, val tagLists: Output<List<String>>? = null, val untagged: Output<Boolean>? = null) : ConvertibleToJava<UserRunnerArgs>

The gitlab.UserRunner resource allows creating a GitLab runner using the new GitLab Runner Registration Flow. Upstream API: GitLab REST API docs

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as gitlab from "@pulumi/gitlab";
// Create a project runner
const projectRunner = new gitlab.UserRunner("project_runner", {
    runnerType: "project_type",
    projectId: 123456,
    description: "A runner created using a user access token instead of a registration token",
    tagLists: [
        "a-tag",
        "other-tag",
    ],
    untagged: true,
});
// Create a group runner
const groupRunner = new gitlab.UserRunner("group_runner", {
    runnerType: "group_type",
    groupId: 123456,
});
// Create a instance runner
const instanceRunner = new gitlab.UserRunner("instance_runner", {runnerType: "instance_type"});
const configToml = pulumi.interpolate`concurrent = 1
check_interval = 0
[session_server]
  session_timeout = 1800
[[runners]]
  name = "my_gitlab_runner"
  url = "https://example.gitlab.com"
  token = "${groupRunner.token}"
  executor = "docker"
  [runners&#46;custom_build_dir]
  [runners&#46;cache]
    [runners&#46;cache&#46;s3]
    [runners&#46;cache&#46;gcs]
    [runners&#46;cache&#46;azure]
  [runners&#46;docker]
    tls_verify = false
    image = "ubuntu"
    privileged = true
    disable_entrypoint_overwrite = false
    oom_kill_disable = false
    disable_cache = false
    volumes = ["/cache", "/certs/client"]
    shm_size = 0
`;
Content copied to clipboard
import pulumi
import pulumi_gitlab as gitlab
# Create a project runner
project_runner = gitlab.UserRunner("project_runner",
    runner_type="project_type",
    project_id=123456,
    description="A runner created using a user access token instead of a registration token",
    tag_lists=[
        "a-tag",
        "other-tag",
    ],
    untagged=True)
# Create a group runner
group_runner = gitlab.UserRunner("group_runner",
    runner_type="group_type",
    group_id=123456)
# Create a instance runner
instance_runner = gitlab.UserRunner("instance_runner", runner_type="instance_type")
config_toml = group_runner.token.apply(lambda token: f"""concurrent = 1
check_interval = 0
[session_server]
  session_timeout = 1800
[[runners]]
  name = "my_gitlab_runner"
  url = "https://example.gitlab.com"
  token = "{token}"
  executor = "docker"
  [runners&#46;custom_build_dir]
  [runners&#46;cache]
    [runners&#46;cache&#46;s3]
    [runners&#46;cache&#46;gcs]
    [runners&#46;cache&#46;azure]
  [runners&#46;docker]
    tls_verify = false
    image = "ubuntu"
    privileged = true
    disable_entrypoint_overwrite = false
    oom_kill_disable = false
    disable_cache = false
    volumes = ["/cache", "/certs/client"]
    shm_size = 0
""")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using GitLab = Pulumi.GitLab;
return await Deployment.RunAsync(() =>
{
    // Create a project runner
    var projectRunner = new GitLab.UserRunner("project_runner", new()
    {
        RunnerType = "project_type",
        ProjectId = 123456,
        Description = "A runner created using a user access token instead of a registration token",
        TagLists = new[]
        {
            "a-tag",
            "other-tag",
        },
        Untagged = true,
    });
    // Create a group runner
    var groupRunner = new GitLab.UserRunner("group_runner", new()
    {
        RunnerType = "group_type",
        GroupId = 123456,
    });
    // Create a instance runner
    var instanceRunner = new GitLab.UserRunner("instance_runner", new()
    {
        RunnerType = "instance_type",
    });
    var configToml = groupRunner.Token.Apply(token => @$"concurrent = 1
check_interval = 0
[session_server]
  session_timeout = 1800
[[runners]]
  name = ""my_gitlab_runner""
  url = ""https://example.gitlab.com""
  token = ""{token}""
  executor = ""docker""
  [runners&#46;custom_build_dir]
  [runners&#46;cache]
    [runners&#46;cache&#46;s3]
    [runners&#46;cache&#46;gcs]
    [runners&#46;cache&#46;azure]
  [runners&#46;docker]
    tls_verify = false
    image = ""ubuntu""
    privileged = true
    disable_entrypoint_overwrite = false
    oom_kill_disable = false
    disable_cache = false
    volumes = [""/cache"", ""/certs/client""]
    shm_size = 0
");
});
Content copied to clipboard
package main
import (
	"fmt"
	"github.com/pulumi/pulumi-gitlab/sdk/v8/go/gitlab"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a project runner
		_, err := gitlab.NewUserRunner(ctx, "project_runner", &gitlab.UserRunnerArgs{
			RunnerType:  pulumi.String("project_type"),
			ProjectId:   pulumi.Int(123456),
			Description: pulumi.String("A runner created using a user access token instead of a registration token"),
			TagLists: pulumi.StringArray{
				pulumi.String("a-tag"),
				pulumi.String("other-tag"),
			},
			Untagged: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Create a group runner
		groupRunner, err := gitlab.NewUserRunner(ctx, "group_runner", &gitlab.UserRunnerArgs{
			RunnerType: pulumi.String("group_type"),
			GroupId:    pulumi.Int(123456),
		})
		if err != nil {
			return err
		}
		// Create a instance runner
		_, err = gitlab.NewUserRunner(ctx, "instance_runner", &gitlab.UserRunnerArgs{
			RunnerType: pulumi.String("instance_type"),
		})
		if err != nil {
			return err
		}
		_ = groupRunner.Token.ApplyT(func(token string) (string, error) {
			return fmt.Sprintf(`concurrent = 1
check_interval = 0
[session_server]
  session_timeout = 1800
[[runners]]
  name = "my_gitlab_runner"
  url = "https://example.gitlab.com"
  token = "%v"
  executor = "docker"
  [runners&#46;custom_build_dir]
  [runners&#46;cache]
    [runners&#46;cache&#46;s3]
    [runners&#46;cache&#46;gcs]
    [runners&#46;cache&#46;azure]
  [runners&#46;docker]
    tls_verify = false
    image = "ubuntu"
    privileged = true
    disable_entrypoint_overwrite = false
    oom_kill_disable = false
    disable_cache = false
    volumes = ["/cache", "/certs/client"]
    shm_size = 0
`, token), nil
		}).(pulumi.StringOutput)
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gitlab.UserRunner;
import com.pulumi.gitlab.UserRunnerArgs;
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) {
        // Create a project runner
        var projectRunner = new UserRunner("projectRunner", UserRunnerArgs.builder()
            .runnerType("project_type")
            .projectId(123456)
            .description("A runner created using a user access token instead of a registration token")
            .tagLists(
                "a-tag",
                "other-tag")
            .untagged(true)
            .build());
        // Create a group runner
        var groupRunner = new UserRunner("groupRunner", UserRunnerArgs.builder()
            .runnerType("group_type")
            .groupId(123456)
            .build());
        // Create a instance runner
        var instanceRunner = new UserRunner("instanceRunner", UserRunnerArgs.builder()
            .runnerType("instance_type")
            .build());
        final var configToml = groupRunner.token().applyValue(token -> """
concurrent = 1
check_interval = 0
[session_server]
  session_timeout = 1800
[[runners]]
  name = "my_gitlab_runner"
  url = "https://example.gitlab.com"
  token = "%s"
  executor = "docker"
  [runners&#46;custom_build_dir]
  [runners&#46;cache]
    [runners&#46;cache&#46;s3]
    [runners&#46;cache&#46;gcs]
    [runners&#46;cache&#46;azure]
  [runners&#46;docker]
    tls_verify = false
    image = "ubuntu"
    privileged = true
    disable_entrypoint_overwrite = false
    oom_kill_disable = false
    disable_cache = false
    volumes = ["/cache", "/certs/client"]
    shm_size = 0
", token));
    }
}
Content copied to clipboard
resources:
  # Create a project runner
  projectRunner:
    type: gitlab:UserRunner
    name: project_runner
    properties:
      runnerType: project_type
      projectId: 123456
      description: A runner created using a user access token instead of a registration token
      tagLists:
        - a-tag
        - other-tag
      untagged: true
  # Create a group runner
  groupRunner:
    type: gitlab:UserRunner
    name: group_runner
    properties:
      runnerType: group_type
      groupId: 123456 # populate other attributes...
  # Create a instance runner
  instanceRunner:
    type: gitlab:UserRunner
    name: instance_runner
    properties:
      runnerType: instance_type
variables:
  configToml: |
    concurrent = 1
    check_interval = 0
    [session_server]
      session_timeout = 1800
    [[runners]]
      name = "my_gitlab_runner"
      url = "https://example.gitlab.com"
      token = "${groupRunner.token}"
      executor = "docker"
      [runners&#46;custom_build_dir]
      [runners&#46;cache]
        [runners&#46;cache&#46;s3]
        [runners&#46;cache&#46;gcs]
        [runners&#46;cache&#46;azure]
      [runners&#46;docker]
        tls_verify = false
        image = "ubuntu"
        privileged = true
        disable_entrypoint_overwrite = false
        oom_kill_disable = false
        disable_cache = false
        volumes = ["/cache", "/certs/client"]
        shm_size = 0
Content copied to clipboard

Import

Starting in Terraform v1.5.0 you can use an import block to import gitlab_user_runner. For example: terraform import { to = gitlab_user_runner.example id = "see CLI command below for ID" } Import using the CLI is supported using the following syntax: You can import a gitlab runner using its ID Note: Importing a runner will not provide access to the token attribute

$ pulumi import gitlab:index/userRunner:UserRunner example 12345
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(accessLevel: Output<String>? = null, description: Output<String>? = null, groupId: Output<Int>? = null, locked: Output<Boolean>? = null, maintenanceNote: Output<String>? = null, maximumTimeout: Output<Int>? = null, paused: Output<Boolean>? = null, projectId: Output<Int>? = null, runnerType: Output<String>? = null, tagLists: Output<List<String>>? = null, untagged: Output<Boolean>? = null)

Properties

Link copied to clipboard
val accessLevel: Output<String>? = null

The access level of the runner. Valid values are: not_protected, ref_protected.

Link copied to clipboard
val description: Output<String>? = null

Description of the runner.

Link copied to clipboard
val groupId: Output<Int>? = null

The ID of the group that the runner is created in. Required if runnertype is grouptype.

Link copied to clipboard
val locked: Output<Boolean>? = null

Specifies if the runner should be locked for the current project.

Link copied to clipboard
val maintenanceNote: Output<String>? = null

Free-form maintenance notes for the runner (1024 characters)

Link copied to clipboard
val maximumTimeout: Output<Int>? = null

Maximum timeout that limits the amount of time (in seconds) that runners can run jobs. Must be at least 600 (10 minutes).

Link copied to clipboard
val paused: Output<Boolean>? = null

Specifies if the runner should ignore new jobs.

Link copied to clipboard
val projectId: Output<Int>? = null

The ID of the project that the runner is created in. Required if runnertype is projecttype.

Link copied to clipboard
val runnerType: Output<String>? = null

The scope of the runner. Valid values are: instance_type, group_type, project_type.

Link copied to clipboard
val tagLists: Output<List<String>>? = null

A list of runner tags.

Link copied to clipboard
val untagged: Output<Boolean>? = null

Specifies if the runner should handle untagged jobs.

Functions

Link copied to clipboard
open override fun toJava(): UserRunnerArgs