gitlab.GroupServiceAccount

import * as pulumi from "@pulumi/pulumi";
import * as gitlab from "@pulumi/gitlab";

// This must be a top-level group
const example = new gitlab.Group("example", {
    name: "example",
    path: "example",
    description: "An example group",
});
// The service account against the top-level group
const exampleSa = new gitlab.GroupServiceAccount("example_sa", {
    group: example.id,
    name: "example-name",
    username: "example-username",
});
// Group to assign the service account to. Can be the same top-level group resource as above, or a subgroup of that group.
const exampleSubgroup = new gitlab.Group("example_subgroup", {
    name: "subgroup",
    path: "example/subgroup",
    description: "An example subgroup",
});
// To assign the service account to a group
const exampleMembership = new gitlab.GroupMembership("example_membership", {
    groupId: exampleSubgroup.id,
    userId: exampleSa.serviceAccountId,
    accessLevel: "developer",
    expiresAt: "2020-03-14",
});

import pulumi
import pulumi_gitlab as gitlab

# This must be a top-level group
example = gitlab.Group("example",
    name="example",
    path="example",
    description="An example group")
# The service account against the top-level group
example_sa = gitlab.GroupServiceAccount("example_sa",
    group=example.id,
    name="example-name",
    username="example-username")
# Group to assign the service account to. Can be the same top-level group resource as above, or a subgroup of that group.
example_subgroup = gitlab.Group("example_subgroup",
    name="subgroup",
    path="example/subgroup",
    description="An example subgroup")
# To assign the service account to a group
example_membership = gitlab.GroupMembership("example_membership",
    group_id=example_subgroup.id,
    user_id=example_sa.service_account_id,
    access_level="developer",
    expires_at="2020-03-14")

package main

import (
	"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 {
		// This must be a top-level group
		example, err := gitlab.NewGroup(ctx, "example", &gitlab.GroupArgs{
			Name:        pulumi.String("example"),
			Path:        pulumi.String("example"),
			Description: pulumi.String("An example group"),
		})
		if err != nil {
			return err
		}
		// The service account against the top-level group
		exampleSa, err := gitlab.NewGroupServiceAccount(ctx, "example_sa", &gitlab.GroupServiceAccountArgs{
			Group:    example.ID(),
			Name:     pulumi.String("example-name"),
			Username: pulumi.String("example-username"),
		})
		if err != nil {
			return err
		}
		// Group to assign the service account to. Can be the same top-level group resource as above, or a subgroup of that group.
		exampleSubgroup, err := gitlab.NewGroup(ctx, "example_subgroup", &gitlab.GroupArgs{
			Name:        pulumi.String("subgroup"),
			Path:        pulumi.String("example/subgroup"),
			Description: pulumi.String("An example subgroup"),
		})
		if err != nil {
			return err
		}
		// To assign the service account to a group
		_, err = gitlab.NewGroupMembership(ctx, "example_membership", &gitlab.GroupMembershipArgs{
			GroupId:     exampleSubgroup.ID(),
			UserId:      exampleSa.ServiceAccountId,
			AccessLevel: pulumi.String("developer"),
			ExpiresAt:   pulumi.String("2020-03-14"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using GitLab = Pulumi.GitLab;

return await Deployment.RunAsync(() => 
{
    // This must be a top-level group
    var example = new GitLab.Group("example", new()
    {
        Name = "example",
        Path = "example",
        Description = "An example group",
    });

    // The service account against the top-level group
    var exampleSa = new GitLab.GroupServiceAccount("example_sa", new()
    {
        Group = example.Id,
        Name = "example-name",
        Username = "example-username",
    });

    // Group to assign the service account to. Can be the same top-level group resource as above, or a subgroup of that group.
    var exampleSubgroup = new GitLab.Group("example_subgroup", new()
    {
        Name = "subgroup",
        Path = "example/subgroup",
        Description = "An example subgroup",
    });

    // To assign the service account to a group
    var exampleMembership = new GitLab.GroupMembership("example_membership", new()
    {
        GroupId = exampleSubgroup.Id,
        UserId = exampleSa.ServiceAccountId,
        AccessLevel = "developer",
        ExpiresAt = "2020-03-14",
    });

});

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.GroupServiceAccount;
import com.pulumi.gitlab.GroupServiceAccountArgs;
import com.pulumi.gitlab.GroupMembership;
import com.pulumi.gitlab.GroupMembershipArgs;
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) {
        // This must be a top-level group
        var example = new Group("example", GroupArgs.builder()
            .name("example")
            .path("example")
            .description("An example group")
            .build());

        // The service account against the top-level group
        var exampleSa = new GroupServiceAccount("exampleSa", GroupServiceAccountArgs.builder()
            .group(example.id())
            .name("example-name")
            .username("example-username")
            .build());

        // Group to assign the service account to. Can be the same top-level group resource as above, or a subgroup of that group.
        var exampleSubgroup = new Group("exampleSubgroup", GroupArgs.builder()
            .name("subgroup")
            .path("example/subgroup")
            .description("An example subgroup")
            .build());

        // To assign the service account to a group
        var exampleMembership = new GroupMembership("exampleMembership", GroupMembershipArgs.builder()
            .groupId(exampleSubgroup.id())
            .userId(exampleSa.serviceAccountId())
            .accessLevel("developer")
            .expiresAt("2020-03-14")
            .build());

    }
}

resources:
  # This must be a top-level group
  example:
    type: gitlab:Group
    properties:
      name: example
      path: example
      description: An example group
  # The service account against the top-level group
  exampleSa:
    type: gitlab:GroupServiceAccount
    name: example_sa
    properties:
      group: ${example.id}
      name: example-name
      username: example-username
  # Group to assign the service account to. Can be the same top-level group resource as above, or a subgroup of that group.
  exampleSubgroup:
    type: gitlab:Group
    name: example_subgroup
    properties:
      name: subgroup
      path: example/subgroup
      description: An example subgroup
  # To assign the service account to a group
  exampleMembership:
    type: gitlab:GroupMembership
    name: example_membership
    properties:
      groupId: ${exampleSubgroup.id}
      userId: ${exampleSa.serviceAccountId}
      accessLevel: developer
      expiresAt: 2020-03-14

var groupServiceAccountResource = new GitLab.GroupServiceAccount("groupServiceAccountResource", new()
{
    Group = "string",
    Name = "string",
    Username = "string",
});

example, err := gitlab.NewGroupServiceAccount(ctx, "groupServiceAccountResource", &gitlab.GroupServiceAccountArgs{
	Group:    pulumi.String("string"),
	Name:     pulumi.String("string"),
	Username: pulumi.String("string"),
})

var groupServiceAccountResource = new GroupServiceAccount("groupServiceAccountResource", GroupServiceAccountArgs.builder()
    .group("string")
    .name("string")
    .username("string")
    .build());

group_service_account_resource = gitlab.GroupServiceAccount("groupServiceAccountResource",
    group="string",
    name="string",
    username="string")

const groupServiceAccountResource = new gitlab.GroupServiceAccount("groupServiceAccountResource", {
    group: "string",
    name: "string",
    username: "string",
});

type: gitlab:GroupServiceAccount
properties:
    group: string
    name: string
    username: string