pulumi-github-kotlin/com.pulumi.github.kotlin/ActionsRunnerGroupArgs

ActionsRunnerGroupArgs

data class ActionsRunnerGroupArgs(val allowsPublicRepositories: Output<Boolean>? = null, val name: Output<String>? = null, val restrictedToWorkflows: Output<Boolean>? = null, val selectedRepositoryIds: Output<List<Int>>? = null, val selectedWorkflows: Output<List<String>>? = null, val visibility: Output<String>? = null) : ConvertibleToJava<ActionsRunnerGroupArgs>

This resource allows you to create and manage GitHub Actions runner groups within your GitHub enterprise organizations. You must have admin access to an organization to use this resource.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as github from "@pulumi/github";
const example = new github.Repository("example", {name: "my-repository"});
const exampleActionsRunnerGroup = new github.ActionsRunnerGroup("example", {
    name: example.name,
    visibility: "selected",
    selectedRepositoryIds: [example&#46;repoId],
});

import pulumi
import pulumi_github as github
example = github.Repository("example", name="my-repository")
example_actions_runner_group = github.ActionsRunnerGroup("example",
    name=example.name,
    visibility="selected",
    selected_repository_ids=[example&#46;repo_id])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Github = Pulumi.Github;
return await Deployment.RunAsync(() =>
{
    var example = new Github.Repository("example", new()
    {
        Name = "my-repository",
    });
    var exampleActionsRunnerGroup = new Github.ActionsRunnerGroup("example", new()
    {
        Name = example.Name,
        Visibility = "selected",
        SelectedRepositoryIds = new[]
        {
            example.RepoId,
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-github/sdk/v6/go/github"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := github.NewRepository(ctx, "example", &github.RepositoryArgs{
			Name: pulumi.String("my-repository"),
		})
		if err != nil {
			return err
		}
		_, err = github.NewActionsRunnerGroup(ctx, "example", &github.ActionsRunnerGroupArgs{
			Name:       example.Name,
			Visibility: pulumi.String("selected"),
			SelectedRepositoryIds: pulumi.IntArray{
				example.RepoId,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.github.Repository;
import com.pulumi.github.RepositoryArgs;
import com.pulumi.github.ActionsRunnerGroup;
import com.pulumi.github.ActionsRunnerGroupArgs;
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) {
        var example = new Repository("example", RepositoryArgs.builder()
            .name("my-repository")
            .build());
        var exampleActionsRunnerGroup = new ActionsRunnerGroup("exampleActionsRunnerGroup", ActionsRunnerGroupArgs.builder()
            .name(example.name())
            .visibility("selected")
            .selectedRepositoryIds(example.repoId())
            .build());
    }
}

resources:
  example:
    type: github:Repository
    properties:
      name: my-repository
  exampleActionsRunnerGroup:
    type: github:ActionsRunnerGroup
    name: example
    properties:
      name: ${example.name}
      visibility: selected
      selectedRepositoryIds:
        - ${example.repoId}

Import

This resource can be imported using the ID of the runner group:

$ pulumi import github:index/actionsRunnerGroup:ActionsRunnerGroup test 7

Constructors

ActionsRunnerGroupArgs

constructor(allowsPublicRepositories: Output<Boolean>? = null, name: Output<String>? = null, restrictedToWorkflows: Output<Boolean>? = null, selectedRepositoryIds: Output<List<Int>>? = null, selectedWorkflows: Output<List<String>>? = null, visibility: Output<String>? = null)

Properties

allowsPublicRepositories

val allowsPublicRepositories: Output<Boolean>? = null

Whether public repositories can be added to the runner group. Defaults to false.

name

val name: Output<String>? = null

Name of the runner group

restrictedToWorkflows

val restrictedToWorkflows: Output<Boolean>? = null

If true, the runner group will be restricted to running only the workflows specified in the selected_workflows array. Defaults to false.

selectedRepositoryIds

val selectedRepositoryIds: Output<List<Int>>? = null

IDs of the repositories which should be added to the runner group

selectedWorkflows

val selectedWorkflows: Output<List<String>>? = null

List of workflows the runner group should be allowed to run. This setting will be ignored unless restricted_to_workflows is set to true.

visibility

val visibility: Output<String>? = null

Visibility of a runner group. Whether the runner group can include all, selected, or private repositories. A value of private is not currently supported due to limitations in the GitHub API.

Functions

toJava

open override fun toJava(): ActionsRunnerGroupArgs