pulumi-github-kotlin/com.pulumi.github.kotlin/OrganizationRuleset

OrganizationRuleset

class OrganizationRuleset : KotlinCustomResource

Creates a GitHub organization ruleset. This resource allows you to create and manage rulesets on the organization level. When applied, a new ruleset will be created. When destroyed, that ruleset will be removed.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as github from "@pulumi/github";
const example = new github.OrganizationRuleset("example", {
    name: "example",
    target: "branch",
    enforcement: "active",
    conditions: {
        refName: {
            includes: ["~ALL"],
            excludes: [],
        },
    },
    bypassActors: [{
        actorId: 13473,
        actorType: "Integration",
        bypassMode: "always",
    }],
    rules: {
        creation: true,
        update: true,
        deletion: true,
        requiredLinearHistory: true,
        requiredSignatures: true,
        branchNamePattern: {
            name: "example",
            negate: false,
            operator: "starts_with",
            pattern: "ex",
        },
    },
});
Content copied to clipboard
import pulumi
import pulumi_github as github
example = github.OrganizationRuleset("example",
    name="example",
    target="branch",
    enforcement="active",
    conditions={
        "ref_name": {
            "includes": ["~ALL"],
            "excludes": [],
        },
    },
    bypass_actors=[{
        "actor_id": 13473,
        "actor_type": "Integration",
        "bypass_mode": "always",
    }],
    rules={
        "creation": True,
        "update": True,
        "deletion": True,
        "required_linear_history": True,
        "required_signatures": True,
        "branch_name_pattern": {
            "name": "example",
            "negate": False,
            "operator": "starts_with",
            "pattern": "ex",
        },
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Github = Pulumi.Github;
return await Deployment.RunAsync(() =>
{
    var example = new Github.OrganizationRuleset("example", new()
    {
        Name = "example",
        Target = "branch",
        Enforcement = "active",
        Conditions = new Github.Inputs.OrganizationRulesetConditionsArgs
        {
            RefName = new Github.Inputs.OrganizationRulesetConditionsRefNameArgs
            {
                Includes = new[]
                {
                    "~ALL",
                },
                Excludes = new() { },
            },
        },
        BypassActors = new[]
        {
            new Github.Inputs.OrganizationRulesetBypassActorArgs
            {
                ActorId = 13473,
                ActorType = "Integration",
                BypassMode = "always",
            },
        },
        Rules = new Github.Inputs.OrganizationRulesetRulesArgs
        {
            Creation = true,
            Update = true,
            Deletion = true,
            RequiredLinearHistory = true,
            RequiredSignatures = true,
            BranchNamePattern = new Github.Inputs.OrganizationRulesetRulesBranchNamePatternArgs
            {
                Name = "example",
                Negate = false,
                Operator = "starts_with",
                Pattern = "ex",
            },
        },
    });
});
Content copied to clipboard
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 {
		_, err := github.NewOrganizationRuleset(ctx, "example", &github.OrganizationRulesetArgs{
			Name:        pulumi.String("example"),
			Target:      pulumi.String("branch"),
			Enforcement: pulumi.String("active"),
			Conditions: &github.OrganizationRulesetConditionsArgs{
				RefName: &github.OrganizationRulesetConditionsRefNameArgs{
					Includes: pulumi.StringArray{
						pulumi.String("~ALL"),
					},
					Excludes: pulumi.StringArray{},
				},
			},
			BypassActors: github.OrganizationRulesetBypassActorArray{
				&github.OrganizationRulesetBypassActorArgs{
					ActorId:    pulumi.Int(13473),
					ActorType:  pulumi.String("Integration"),
					BypassMode: pulumi.String("always"),
				},
			},
			Rules: &github.OrganizationRulesetRulesArgs{
				Creation:              pulumi.Bool(true),
				Update:                pulumi.Bool(true),
				Deletion:              pulumi.Bool(true),
				RequiredLinearHistory: pulumi.Bool(true),
				RequiredSignatures:    pulumi.Bool(true),
				BranchNamePattern: &github.OrganizationRulesetRulesBranchNamePatternArgs{
					Name:     pulumi.String("example"),
					Negate:   pulumi.Bool(false),
					Operator: pulumi.String("starts_with"),
					Pattern:  pulumi.String("ex"),
				},
			},
		})
		if err != nil {
			return err
		}
		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.github.OrganizationRuleset;
import com.pulumi.github.OrganizationRulesetArgs;
import com.pulumi.github.inputs.OrganizationRulesetConditionsArgs;
import com.pulumi.github.inputs.OrganizationRulesetConditionsRefNameArgs;
import com.pulumi.github.inputs.OrganizationRulesetBypassActorArgs;
import com.pulumi.github.inputs.OrganizationRulesetRulesArgs;
import com.pulumi.github.inputs.OrganizationRulesetRulesBranchNamePatternArgs;
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 OrganizationRuleset("example", OrganizationRulesetArgs.builder()
            .name("example")
            .target("branch")
            .enforcement("active")
            .conditions(OrganizationRulesetConditionsArgs.builder()
                .refName(OrganizationRulesetConditionsRefNameArgs.builder()
                    .includes("~ALL")
                    .excludes()
                    .build())
                .build())
            .bypassActors(OrganizationRulesetBypassActorArgs.builder()
                .actorId(13473)
                .actorType("Integration")
                .bypassMode("always")
                .build())
            .rules(OrganizationRulesetRulesArgs.builder()
                .creation(true)
                .update(true)
                .deletion(true)
                .requiredLinearHistory(true)
                .requiredSignatures(true)
                .branchNamePattern(OrganizationRulesetRulesBranchNamePatternArgs.builder()
                    .name("example")
                    .negate(false)
                    .operator("starts_with")
                    .pattern("ex")
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: github:OrganizationRuleset
    properties:
      name: example
      target: branch
      enforcement: active
      conditions:
        refName:
          includes:
            - ~ALL
          excludes: []
      bypassActors:
        - actorId: 13473
          actorType: Integration
          bypassMode: always
      rules:
        creation: true
        update: true
        deletion: true
        requiredLinearHistory: true
        requiredSignatures: true
        branchNamePattern:
          name: example
          negate: false
          operator: starts_with
          pattern: ex
Content copied to clipboard

Import

GitHub Organization Rulesets can be imported using the GitHub ruleset ID e.g.

$ pulumi import github:index/organizationRuleset:OrganizationRuleset example 12345`
Content copied to clipboard

Properties

Link copied to clipboard
val bypassActors: Output<List<OrganizationRulesetBypassActor>>?

(Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema)

Link copied to clipboard
val conditions: Output<OrganizationRulesetConditions>?

(Block List, Max: 1) Parameters for an organization ruleset condition. ref_name is required alongside one of repository_name or repository_id. (see below for nested schema)

Link copied to clipboard
val enforcement: Output<String>

(String) Possible values for Enforcement are disabled, active, evaluate. Note: evaluate is currently only supported for owners of type organization.

Link copied to clipboard
val etag: Output<String>

(String)

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val name: Output<String>

(String) The name of the ruleset.

Link copied to clipboard
val nodeId: Output<String>

(String) GraphQL global node id for use with v4 API.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val rules: Output<OrganizationRulesetRules>

(Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema)

Link copied to clipboard
val rulesetId: Output<Int>

(Number) GitHub ID for the ruleset.

Link copied to clipboard
val target: Output<String>

(String) Possible values are branch and tag.

Link copied to clipboard
val urn: Output<String>