UserRunner

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.custom_build_dir]
  [runners.cache]
    [runners.cache.s3]
    [runners.cache.gcs]
    [runners.cache.azure]
  [runners.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
`;

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.custom_build_dir]
  [runners.cache]
    [runners.cache.s3]
    [runners.cache.gcs]
    [runners.cache.azure]
  [runners.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
""")

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.custom_build_dir]
  [runners.cache]
    [runners.cache.s3]
    [runners.cache.gcs]
    [runners.cache.azure]
  [runners.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
");
});

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.custom_build_dir]
  [runners.cache]
    [runners.cache.s3]
    [runners.cache.gcs]
    [runners.cache.azure]
  [runners.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
	})
}

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.custom_build_dir]
  [runners.cache]
    [runners.cache.s3]
    [runners.cache.gcs]
    [runners.cache.azure]
  [runners.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));
    }
}

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.custom_build_dir]
      [runners.cache]
        [runners.cache.s3]
        [runners.cache.gcs]
        [runners.cache.azure]
      [runners.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

$ pulumi import gitlab:index/userRunner:UserRunner example 12345