pulumi-github-kotlin/com.pulumi.github.kotlin/TeamMembership

TeamMembership

class TeamMembership : KotlinCustomResource

Provides a GitHub team membership resource. This resource allows you to add/remove users from teams in your organization. When applied, the user will be added to the team. If the user hasn't accepted their invitation to the organization, they won't be part of the team until they do. When destroyed, the user will be removed from the team.

Note This resource is not compatible with github.TeamMembers. Use either github.TeamMembers or github.TeamMembership. Note Organization owners may not be set as "members" of a team; they may only be set as "maintainers". Attempting to set an organization owner as a "member" of a team may result in a pulumi preview diff that changes their status back to "maintainer".

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as github from "@pulumi/github";
// Add a user to the organization
const membershipForSomeUser = new github.Membership("membership_for_some_user", {
    username: "SomeUser",
    role: "member",
});
const someTeam = new github.Team("some_team", {
    name: "SomeTeam",
    description: "Some cool team",
});
const someTeamMembership = new github.TeamMembership("some_team_membership", {
    teamId: someTeam.id,
    username: "SomeUser",
    role: "member",
});

import pulumi
import pulumi_github as github
# Add a user to the organization
membership_for_some_user = github.Membership("membership_for_some_user",
    username="SomeUser",
    role="member")
some_team = github.Team("some_team",
    name="SomeTeam",
    description="Some cool team")
some_team_membership = github.TeamMembership("some_team_membership",
    team_id=some_team.id,
    username="SomeUser",
    role="member")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Github = Pulumi.Github;
return await Deployment.RunAsync(() =>
{
    // Add a user to the organization
    var membershipForSomeUser = new Github.Membership("membership_for_some_user", new()
    {
        Username = "SomeUser",
        Role = "member",
    });
    var someTeam = new Github.Team("some_team", new()
    {
        Name = "SomeTeam",
        Description = "Some cool team",
    });
    var someTeamMembership = new Github.TeamMembership("some_team_membership", new()
    {
        TeamId = someTeam.Id,
        Username = "SomeUser",
        Role = "member",
    });
});

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 {
		// Add a user to the organization
		_, err := github.NewMembership(ctx, "membership_for_some_user", &github.MembershipArgs{
			Username: pulumi.String("SomeUser"),
			Role:     pulumi.String("member"),
		})
		if err != nil {
			return err
		}
		someTeam, err := github.NewTeam(ctx, "some_team", &github.TeamArgs{
			Name:        pulumi.String("SomeTeam"),
			Description: pulumi.String("Some cool team"),
		})
		if err != nil {
			return err
		}
		_, err = github.NewTeamMembership(ctx, "some_team_membership", &github.TeamMembershipArgs{
			TeamId:   someTeam.ID(),
			Username: pulumi.String("SomeUser"),
			Role:     pulumi.String("member"),
		})
		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.Membership;
import com.pulumi.github.MembershipArgs;
import com.pulumi.github.Team;
import com.pulumi.github.TeamArgs;
import com.pulumi.github.TeamMembership;
import com.pulumi.github.TeamMembershipArgs;
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) {
        // Add a user to the organization
        var membershipForSomeUser = new Membership("membershipForSomeUser", MembershipArgs.builder()
            .username("SomeUser")
            .role("member")
            .build());
        var someTeam = new Team("someTeam", TeamArgs.builder()
            .name("SomeTeam")
            .description("Some cool team")
            .build());
        var someTeamMembership = new TeamMembership("someTeamMembership", TeamMembershipArgs.builder()
            .teamId(someTeam.id())
            .username("SomeUser")
            .role("member")
            .build());
    }
}

resources:
  # Add a user to the organization
  membershipForSomeUser:
    type: github:Membership
    name: membership_for_some_user
    properties:
      username: SomeUser
      role: member
  someTeam:
    type: github:Team
    name: some_team
    properties:
      name: SomeTeam
      description: Some cool team
  someTeamMembership:
    type: github:TeamMembership
    name: some_team_membership
    properties:
      teamId: ${someTeam.id}
      username: SomeUser
      role: member

Import

GitHub Team Membership can be imported using an ID made up of teamid:username or teamname:username, e.g.

$ pulumi import github:index/teamMembership:TeamMembership member 1234567:someuser

$ pulumi import github:index/teamMembership:TeamMembership member Administrators:someuser

Properties

etag

val etag: Output<String>

val id: Output<String>

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

role

val role: Output<String>?

The role of the user within the team. Must be one of member or maintainer. Defaults to member.

teamId

val teamId: Output<String>

The GitHub team id or the GitHub team slug

urn

val urn: Output<String>

username

val username: Output<String>

The user to add to the team.