aws.iam.GroupMembership

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

const group = new aws.iam.Group("group", {name: "test-group"});
const userOne = new aws.iam.User("user_one", {name: "test-user"});
const userTwo = new aws.iam.User("user_two", {name: "test-user-two"});
const team = new aws.iam.GroupMembership("team", {
    name: "tf-testing-group-membership",
    users: [
        userOne.name,
        userTwo.name,
    ],
    group: group.name,
});

import pulumi
import pulumi_aws as aws

group = aws.iam.Group("group", name="test-group")
user_one = aws.iam.User("user_one", name="test-user")
user_two = aws.iam.User("user_two", name="test-user-two")
team = aws.iam.GroupMembership("team",
    name="tf-testing-group-membership",
    users=[
        user_one.name,
        user_two.name,
    ],
    group=group.name)

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		group, err := iam.NewGroup(ctx, "group", &iam.GroupArgs{
			Name: pulumi.String("test-group"),
		})
		if err != nil {
			return err
		}
		userOne, err := iam.NewUser(ctx, "user_one", &iam.UserArgs{
			Name: pulumi.String("test-user"),
		})
		if err != nil {
			return err
		}
		userTwo, err := iam.NewUser(ctx, "user_two", &iam.UserArgs{
			Name: pulumi.String("test-user-two"),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewGroupMembership(ctx, "team", &iam.GroupMembershipArgs{
			Name: pulumi.String("tf-testing-group-membership"),
			Users: pulumi.StringArray{
				userOne.Name,
				userTwo.Name,
			},
			Group: group.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @group = new Aws.Iam.Group("group", new()
    {
        Name = "test-group",
    });

    var userOne = new Aws.Iam.User("user_one", new()
    {
        Name = "test-user",
    });

    var userTwo = new Aws.Iam.User("user_two", new()
    {
        Name = "test-user-two",
    });

    var team = new Aws.Iam.GroupMembership("team", new()
    {
        Name = "tf-testing-group-membership",
        Users = new[]
        {
            userOne.Name,
            userTwo.Name,
        },
        Group = @group.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.iam.Group;
import com.pulumi.aws.iam.GroupArgs;
import com.pulumi.aws.iam.User;
import com.pulumi.aws.iam.UserArgs;
import com.pulumi.aws.iam.GroupMembership;
import com.pulumi.aws.iam.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) {
        var group = new Group("group", GroupArgs.builder()        
            .name("test-group")
            .build());

        var userOne = new User("userOne", UserArgs.builder()        
            .name("test-user")
            .build());

        var userTwo = new User("userTwo", UserArgs.builder()        
            .name("test-user-two")
            .build());

        var team = new GroupMembership("team", GroupMembershipArgs.builder()        
            .name("tf-testing-group-membership")
            .users(            
                userOne.name(),
                userTwo.name())
            .group(group.name())
            .build());

    }
}

resources:
  team:
    type: aws:iam:GroupMembership
    properties:
      name: tf-testing-group-membership
      users:
        - ${userOne.name}
        - ${userTwo.name}
      group: ${group.name}
  group:
    type: aws:iam:Group
    properties:
      name: test-group
  userOne:
    type: aws:iam:User
    name: user_one
    properties:
      name: test-user
  userTwo:
    type: aws:iam:User
    name: user_two
    properties:
      name: test-user-two

var groupMembershipResource = new Aws.Iam.GroupMembership("groupMembershipResource", new()
{
    Group = "string",
    Users = new[]
    {
        "string",
    },
    Name = "string",
});

example, err := iam.NewGroupMembership(ctx, "groupMembershipResource", &iam.GroupMembershipArgs{
	Group: pulumi.String("string"),
	Users: pulumi.StringArray{
		pulumi.String("string"),
	},
	Name: pulumi.String("string"),
})

var groupMembershipResource = new GroupMembership("groupMembershipResource", GroupMembershipArgs.builder()        
    .group("string")
    .users("string")
    .name("string")
    .build());

group_membership_resource = aws.iam.GroupMembership("groupMembershipResource",
    group="string",
    users=["string"],
    name="string")

const groupMembershipResource = new aws.iam.GroupMembership("groupMembershipResource", {
    group: "string",
    users: ["string"],
    name: "string",
});

type: aws:iam:GroupMembership
properties:
    group: string
    name: string
    users:
        - string