GroupArgs

import * as pulumi from "@pulumi/pulumi";
import * as gitlab from "@pulumi/gitlab";
const exampleGroup = new gitlab.Group("exampleGroup", {
    path: "example",
    description: "An example group",
});
// Create a project in the example group
const exampleProject = new gitlab.Project("exampleProject", {
    description: "An example project",
    namespaceId: exampleGroup.id,
});
// Group with custom push rules
const example_two = new gitlab.Group("example-two", {
    path: "example-two",
    description: "An example group with push rules",
    pushRules: {
        authorEmailRegex: "@example\\.com$",
        commitCommitterCheck: true,
        memberCheck: true,
        preventSecrets: true,
    },
});

import pulumi
import pulumi_gitlab as gitlab
example_group = gitlab.Group("exampleGroup",
    path="example",
    description="An example group")
# Create a project in the example group
example_project = gitlab.Project("exampleProject",
    description="An example project",
    namespace_id=example_group.id)
# Group with custom push rules
example_two = gitlab.Group("example-two",
    path="example-two",
    description="An example group with push rules",
    push_rules=gitlab.GroupPushRulesArgs(
        author_email_regex="@example\\.com$",
        commit_committer_check=True,
        member_check=True,
        prevent_secrets=True,
    ))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using GitLab = Pulumi.GitLab;
return await Deployment.RunAsync(() =>
{
    var exampleGroup = new GitLab.Group("exampleGroup", new()
    {
        Path = "example",
        Description = "An example group",
    });
    // Create a project in the example group
    var exampleProject = new GitLab.Project("exampleProject", new()
    {
        Description = "An example project",
        NamespaceId = exampleGroup.Id,
    });
    // Group with custom push rules
    var example_two = new GitLab.Group("example-two", new()
    {
        Path = "example-two",
        Description = "An example group with push rules",
        PushRules = new GitLab.Inputs.GroupPushRulesArgs
        {
            AuthorEmailRegex = "@example\\.com$",
            CommitCommitterCheck = true,
            MemberCheck = true,
            PreventSecrets = true,
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gitlab/sdk/v6/go/gitlab"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleGroup, err := gitlab.NewGroup(ctx, "exampleGroup", &gitlab.GroupArgs{
			Path:        pulumi.String("example"),
			Description: pulumi.String("An example group"),
		})
		if err != nil {
			return err
		}
		// Create a project in the example group
		_, err = gitlab.NewProject(ctx, "exampleProject", &gitlab.ProjectArgs{
			Description: pulumi.String("An example project"),
			NamespaceId: exampleGroup.ID(),
		})
		if err != nil {
			return err
		}
		// Group with custom push rules
		_, err = gitlab.NewGroup(ctx, "example-two", &gitlab.GroupArgs{
			Path:        pulumi.String("example-two"),
			Description: pulumi.String("An example group with push rules"),
			PushRules: &gitlab.GroupPushRulesArgs{
				AuthorEmailRegex:     pulumi.String("@example\\.com$"),
				CommitCommitterCheck: pulumi.Bool(true),
				MemberCheck:          pulumi.Bool(true),
				PreventSecrets:       pulumi.Bool(true),
			},
		})
		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.gitlab.Group;
import com.pulumi.gitlab.GroupArgs;
import com.pulumi.gitlab.Project;
import com.pulumi.gitlab.ProjectArgs;
import com.pulumi.gitlab.inputs.GroupPushRulesArgs;
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 exampleGroup = new Group("exampleGroup", GroupArgs.builder()
            .path("example")
            .description("An example group")
            .build());
        // Create a project in the example group
        var exampleProject = new Project("exampleProject", ProjectArgs.builder()
            .description("An example project")
            .namespaceId(exampleGroup.id())
            .build());
        // Group with custom push rules
        var example_two = new Group("example-two", GroupArgs.builder()
            .path("example-two")
            .description("An example group with push rules")
            .pushRules(GroupPushRulesArgs.builder()
                .authorEmailRegex("@example\\.com$")
                .commitCommitterCheck(true)
                .memberCheck(true)
                .preventSecrets(true)
                .build())
            .build());
    }
}

resources:
  exampleGroup:
    type: gitlab:Group
    properties:
      path: example
      description: An example group
  # Create a project in the example group
  exampleProject:
    type: gitlab:Project
    properties:
      description: An example project
      namespaceId: ${exampleGroup.id}
  # Group with custom push rules
  example-two:
    type: gitlab:Group
    properties:
      path: example-two
      description: An example group with push rules
      pushRules:
        authorEmailRegex: '@example\.com$'
        commitCommitterCheck: true
        memberCheck: true
        preventSecrets: true

$ pulumi import gitlab:index/group:Group You can import a group state using `<resource> <id>`. The

$ pulumi import gitlab:index/group:Group example example