aws.cognito.UserInGroup

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

const example = new aws.cognito.UserPool("example", {
    name: "example",
    passwordPolicy: {
        temporaryPasswordValidityDays: 7,
        minimumLength: 6,
        requireUppercase: false,
        requireSymbols: false,
        requireNumbers: false,
    },
});
const exampleUser = new aws.cognito.User("example", {
    userPoolId: example.id,
    username: "example",
});
const exampleUserGroup = new aws.cognito.UserGroup("example", {
    userPoolId: example.id,
    name: "example",
});
const exampleUserInGroup = new aws.cognito.UserInGroup("example", {
    userPoolId: example.id,
    groupName: exampleUserGroup.name,
    username: exampleUser.username,
});

import pulumi
import pulumi_aws as aws

example = aws.cognito.UserPool("example",
    name="example",
    password_policy={
        "temporary_password_validity_days": 7,
        "minimum_length": 6,
        "require_uppercase": False,
        "require_symbols": False,
        "require_numbers": False,
    })
example_user = aws.cognito.User("example",
    user_pool_id=example.id,
    username="example")
example_user_group = aws.cognito.UserGroup("example",
    user_pool_id=example.id,
    name="example")
example_user_in_group = aws.cognito.UserInGroup("example",
    user_pool_id=example.id,
    group_name=example_user_group.name,
    username=example_user.username)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := cognito.NewUserPool(ctx, "example", &cognito.UserPoolArgs{
			Name: pulumi.String("example"),
			PasswordPolicy: &cognito.UserPoolPasswordPolicyArgs{
				TemporaryPasswordValidityDays: pulumi.Int(7),
				MinimumLength:                 pulumi.Int(6),
				RequireUppercase:              pulumi.Bool(false),
				RequireSymbols:                pulumi.Bool(false),
				RequireNumbers:                pulumi.Bool(false),
			},
		})
		if err != nil {
			return err
		}
		exampleUser, err := cognito.NewUser(ctx, "example", &cognito.UserArgs{
			UserPoolId: example.ID(),
			Username:   pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		exampleUserGroup, err := cognito.NewUserGroup(ctx, "example", &cognito.UserGroupArgs{
			UserPoolId: example.ID(),
			Name:       pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		_, err = cognito.NewUserInGroup(ctx, "example", &cognito.UserInGroupArgs{
			UserPoolId: example.ID(),
			GroupName:  exampleUserGroup.Name,
			Username:   exampleUser.Username,
		})
		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 example = new Aws.Cognito.UserPool("example", new()
    {
        Name = "example",
        PasswordPolicy = new Aws.Cognito.Inputs.UserPoolPasswordPolicyArgs
        {
            TemporaryPasswordValidityDays = 7,
            MinimumLength = 6,
            RequireUppercase = false,
            RequireSymbols = false,
            RequireNumbers = false,
        },
    });

    var exampleUser = new Aws.Cognito.User("example", new()
    {
        UserPoolId = example.Id,
        Username = "example",
    });

    var exampleUserGroup = new Aws.Cognito.UserGroup("example", new()
    {
        UserPoolId = example.Id,
        Name = "example",
    });

    var exampleUserInGroup = new Aws.Cognito.UserInGroup("example", new()
    {
        UserPoolId = example.Id,
        GroupName = exampleUserGroup.Name,
        Username = exampleUser.Username,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cognito.UserPool;
import com.pulumi.aws.cognito.UserPoolArgs;
import com.pulumi.aws.cognito.inputs.UserPoolPasswordPolicyArgs;
import com.pulumi.aws.cognito.User;
import com.pulumi.aws.cognito.UserArgs;
import com.pulumi.aws.cognito.UserGroup;
import com.pulumi.aws.cognito.UserGroupArgs;
import com.pulumi.aws.cognito.UserInGroup;
import com.pulumi.aws.cognito.UserInGroupArgs;
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 UserPool("example", UserPoolArgs.builder()
            .name("example")
            .passwordPolicy(UserPoolPasswordPolicyArgs.builder()
                .temporaryPasswordValidityDays(7)
                .minimumLength(6)
                .requireUppercase(false)
                .requireSymbols(false)
                .requireNumbers(false)
                .build())
            .build());

        var exampleUser = new User("exampleUser", UserArgs.builder()
            .userPoolId(example.id())
            .username("example")
            .build());

        var exampleUserGroup = new UserGroup("exampleUserGroup", UserGroupArgs.builder()
            .userPoolId(example.id())
            .name("example")
            .build());

        var exampleUserInGroup = new UserInGroup("exampleUserInGroup", UserInGroupArgs.builder()
            .userPoolId(example.id())
            .groupName(exampleUserGroup.name())
            .username(exampleUser.username())
            .build());

    }
}

resources:
  example:
    type: aws:cognito:UserPool
    properties:
      name: example
      passwordPolicy:
        temporaryPasswordValidityDays: 7
        minimumLength: 6
        requireUppercase: false
        requireSymbols: false
        requireNumbers: false
  exampleUser:
    type: aws:cognito:User
    name: example
    properties:
      userPoolId: ${example.id}
      username: example
  exampleUserGroup:
    type: aws:cognito:UserGroup
    name: example
    properties:
      userPoolId: ${example.id}
      name: example
  exampleUserInGroup:
    type: aws:cognito:UserInGroup
    name: example
    properties:
      userPoolId: ${example.id}
      groupName: ${exampleUserGroup.name}
      username: ${exampleUser.username}

var userInGroupResource = new Aws.Cognito.UserInGroup("userInGroupResource", new()
{
    GroupName = "string",
    UserPoolId = "string",
    Username = "string",
});

example, err := cognito.NewUserInGroup(ctx, "userInGroupResource", &cognito.UserInGroupArgs{
	GroupName:  pulumi.String("string"),
	UserPoolId: pulumi.String("string"),
	Username:   pulumi.String("string"),
})

var userInGroupResource = new UserInGroup("userInGroupResource", UserInGroupArgs.builder()
    .groupName("string")
    .userPoolId("string")
    .username("string")
    .build());

user_in_group_resource = aws.cognito.UserInGroup("userInGroupResource",
    group_name="string",
    user_pool_id="string",
    username="string")

const userInGroupResource = new aws.cognito.UserInGroup("userInGroupResource", {
    groupName: "string",
    userPoolId: "string",
    username: "string",
});

type: aws:cognito:UserInGroup
properties:
    groupName: string
    userPoolId: string
    username: string