alicloud.bastionhost.HostGroupAccountUserAttachment

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

const config = new pulumi.Config();
const name = config.get("name") || "tf_example";
const defaultZones = alicloud.getZones({
    availableResourceCreation: "VSwitch",
});
const defaultNetworks = alicloud.vpc.getNetworks({
    nameRegex: "^default-NODELETING$",
    cidrBlock: "10.4.0.0/16",
});
const defaultSwitches = Promise.all([defaultNetworks, defaultZones]).then(([defaultNetworks, defaultZones]) => alicloud.vpc.getSwitches({
    cidrBlock: "10.4.0.0/24",
    vpcId: defaultNetworks.ids?.[0],
    zoneId: defaultZones.zones?.[0]?.id,
}));
const defaultSecurityGroup = new alicloud.ecs.SecurityGroup("defaultSecurityGroup", {vpcId: defaultNetworks.then(defaultNetworks => defaultNetworks.ids?.[0])});
const defaultInstance = new alicloud.bastionhost.Instance("defaultInstance", {
    description: name,
    licenseCode: "bhah_ent_50_asset",
    planCode: "cloudbastion",
    storage: "5",
    bandwidth: "5",
    period: 1,
    vswitchId: defaultSwitches.then(defaultSwitches => defaultSwitches.ids?.[0]),
    securityGroupIds: [defaultSecurityGroup.id],
});
const localUser = new alicloud.bastionhost.User("localUser", {
    instanceId: defaultInstance.id,
    mobileCountryCode: "CN",
    mobile: "13312345678",
    password: "YourPassword-123",
    source: "Local",
    userName: `${name}_local_user`,
});
const defaultHost = new alicloud.bastionhost.Host("defaultHost", {
    instanceId: defaultInstance.id,
    hostName: name,
    activeAddressType: "Private",
    hostPrivateAddress: "172.16.0.10",
    osType: "Linux",
    source: "Local",
});
const defaultHostAccount = new alicloud.bastionhost.HostAccount("defaultHostAccount", {
    hostAccountName: name,
    hostId: defaultHost.hostId,
    instanceId: defaultHost.instanceId,
    protocolName: "SSH",
    password: "YourPassword12345",
});
const defaultHostGroup = new alicloud.bastionhost.HostGroup("defaultHostGroup", {
    hostGroupName: name,
    instanceId: defaultInstance.id,
});
const defaultHostGroupAccountUserAttachment = new alicloud.bastionhost.HostGroupAccountUserAttachment("defaultHostGroupAccountUserAttachment", {
    instanceId: defaultHost.instanceId,
    userId: localUser.userId,
    hostGroupId: defaultHostGroup.hostGroupId,
    hostAccountNames: [defaultHostAccount.hostAccountName],
});

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "tf_example"
default_zones = alicloud.get_zones(available_resource_creation="VSwitch")
default_networks = alicloud.vpc.get_networks(name_regex="^default-NODELETING$",
    cidr_block="10.4.0.0/16")
default_switches = alicloud.vpc.get_switches(cidr_block="10.4.0.0/24",
    vpc_id=default_networks.ids[0],
    zone_id=default_zones.zones[0].id)
default_security_group = alicloud.ecs.SecurityGroup("defaultSecurityGroup", vpc_id=default_networks.ids[0])
default_instance = alicloud.bastionhost.Instance("defaultInstance",
    description=name,
    license_code="bhah_ent_50_asset",
    plan_code="cloudbastion",
    storage="5",
    bandwidth="5",
    period=1,
    vswitch_id=default_switches.ids[0],
    security_group_ids=[default_security_group.id])
local_user = alicloud.bastionhost.User("localUser",
    instance_id=default_instance.id,
    mobile_country_code="CN",
    mobile="13312345678",
    password="YourPassword-123",
    source="Local",
    user_name=f"{name}_local_user")
default_host = alicloud.bastionhost.Host("defaultHost",
    instance_id=default_instance.id,
    host_name=name,
    active_address_type="Private",
    host_private_address="172.16.0.10",
    os_type="Linux",
    source="Local")
default_host_account = alicloud.bastionhost.HostAccount("defaultHostAccount",
    host_account_name=name,
    host_id=default_host.host_id,
    instance_id=default_host.instance_id,
    protocol_name="SSH",
    password="YourPassword12345")
default_host_group = alicloud.bastionhost.HostGroup("defaultHostGroup",
    host_group_name=name,
    instance_id=default_instance.id)
default_host_group_account_user_attachment = alicloud.bastionhost.HostGroupAccountUserAttachment("defaultHostGroupAccountUserAttachment",
    instance_id=default_host.instance_id,
    user_id=local_user.user_id,
    host_group_id=default_host_group.host_group_id,
    host_account_names=[default_host_account.host_account_name])

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/bastionhost"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ecs"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "tf_example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultZones, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
			AvailableResourceCreation: pulumi.StringRef("VSwitch"),
		}, nil)
		if err != nil {
			return err
		}
		defaultNetworks, err := vpc.GetNetworks(ctx, &vpc.GetNetworksArgs{
			NameRegex: pulumi.StringRef("^default-NODELETING$"),
			CidrBlock: pulumi.StringRef("10.4.0.0/16"),
		}, nil)
		if err != nil {
			return err
		}
		defaultSwitches, err := vpc.GetSwitches(ctx, &vpc.GetSwitchesArgs{
			CidrBlock: pulumi.StringRef("10.4.0.0/24"),
			VpcId:     pulumi.StringRef(defaultNetworks.Ids[0]),
			ZoneId:    pulumi.StringRef(defaultZones.Zones[0].Id),
		}, nil)
		if err != nil {
			return err
		}
		defaultSecurityGroup, err := ecs.NewSecurityGroup(ctx, "defaultSecurityGroup", &ecs.SecurityGroupArgs{
			VpcId: pulumi.String(defaultNetworks.Ids[0]),
		})
		if err != nil {
			return err
		}
		defaultInstance, err := bastionhost.NewInstance(ctx, "defaultInstance", &bastionhost.InstanceArgs{
			Description: pulumi.String(name),
			LicenseCode: pulumi.String("bhah_ent_50_asset"),
			PlanCode:    pulumi.String("cloudbastion"),
			Storage:     pulumi.String("5"),
			Bandwidth:   pulumi.String("5"),
			Period:      pulumi.Int(1),
			VswitchId:   pulumi.String(defaultSwitches.Ids[0]),
			SecurityGroupIds: pulumi.StringArray{
				defaultSecurityGroup.ID(),
			},
		})
		if err != nil {
			return err
		}
		localUser, err := bastionhost.NewUser(ctx, "localUser", &bastionhost.UserArgs{
			InstanceId:        defaultInstance.ID(),
			MobileCountryCode: pulumi.String("CN"),
			Mobile:            pulumi.String("13312345678"),
			Password:          pulumi.String("YourPassword-123"),
			Source:            pulumi.String("Local"),
			UserName:          pulumi.String(fmt.Sprintf("%v_local_user", name)),
		})
		if err != nil {
			return err
		}
		defaultHost, err := bastionhost.NewHost(ctx, "defaultHost", &bastionhost.HostArgs{
			InstanceId:         defaultInstance.ID(),
			HostName:           pulumi.String(name),
			ActiveAddressType:  pulumi.String("Private"),
			HostPrivateAddress: pulumi.String("172.16.0.10"),
			OsType:             pulumi.String("Linux"),
			Source:             pulumi.String("Local"),
		})
		if err != nil {
			return err
		}
		defaultHostAccount, err := bastionhost.NewHostAccount(ctx, "defaultHostAccount", &bastionhost.HostAccountArgs{
			HostAccountName: pulumi.String(name),
			HostId:          defaultHost.HostId,
			InstanceId:      defaultHost.InstanceId,
			ProtocolName:    pulumi.String("SSH"),
			Password:        pulumi.String("YourPassword12345"),
		})
		if err != nil {
			return err
		}
		defaultHostGroup, err := bastionhost.NewHostGroup(ctx, "defaultHostGroup", &bastionhost.HostGroupArgs{
			HostGroupName: pulumi.String(name),
			InstanceId:    defaultInstance.ID(),
		})
		if err != nil {
			return err
		}
		_, err = bastionhost.NewHostGroupAccountUserAttachment(ctx, "defaultHostGroupAccountUserAttachment", &bastionhost.HostGroupAccountUserAttachmentArgs{
			InstanceId:  defaultHost.InstanceId,
			UserId:      localUser.UserId,
			HostGroupId: defaultHostGroup.HostGroupId,
			HostAccountNames: pulumi.StringArray{
				defaultHostAccount.HostAccountName,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "tf_example";
    var defaultZones = AliCloud.GetZones.Invoke(new()
    {
        AvailableResourceCreation = "VSwitch",
    });

    var defaultNetworks = AliCloud.Vpc.GetNetworks.Invoke(new()
    {
        NameRegex = "^default-NODELETING$",
        CidrBlock = "10.4.0.0/16",
    });

    var defaultSwitches = AliCloud.Vpc.GetSwitches.Invoke(new()
    {
        CidrBlock = "10.4.0.0/24",
        VpcId = defaultNetworks.Apply(getNetworksResult => getNetworksResult.Ids[0]),
        ZoneId = defaultZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
    });

    var defaultSecurityGroup = new AliCloud.Ecs.SecurityGroup("defaultSecurityGroup", new()
    {
        VpcId = defaultNetworks.Apply(getNetworksResult => getNetworksResult.Ids[0]),
    });

    var defaultInstance = new AliCloud.BastionHost.Instance("defaultInstance", new()
    {
        Description = name,
        LicenseCode = "bhah_ent_50_asset",
        PlanCode = "cloudbastion",
        Storage = "5",
        Bandwidth = "5",
        Period = 1,
        VswitchId = defaultSwitches.Apply(getSwitchesResult => getSwitchesResult.Ids[0]),
        SecurityGroupIds = new[]
        {
            defaultSecurityGroup.Id,
        },
    });

    var localUser = new AliCloud.BastionHost.User("localUser", new()
    {
        InstanceId = defaultInstance.Id,
        MobileCountryCode = "CN",
        Mobile = "13312345678",
        Password = "YourPassword-123",
        Source = "Local",
        UserName = $"{name}_local_user",
    });

    var defaultHost = new AliCloud.BastionHost.Host("defaultHost", new()
    {
        InstanceId = defaultInstance.Id,
        HostName = name,
        ActiveAddressType = "Private",
        HostPrivateAddress = "172.16.0.10",
        OsType = "Linux",
        Source = "Local",
    });

    var defaultHostAccount = new AliCloud.BastionHost.HostAccount("defaultHostAccount", new()
    {
        HostAccountName = name,
        HostId = defaultHost.HostId,
        InstanceId = defaultHost.InstanceId,
        ProtocolName = "SSH",
        Password = "YourPassword12345",
    });

    var defaultHostGroup = new AliCloud.BastionHost.HostGroup("defaultHostGroup", new()
    {
        HostGroupName = name,
        InstanceId = defaultInstance.Id,
    });

    var defaultHostGroupAccountUserAttachment = new AliCloud.BastionHost.HostGroupAccountUserAttachment("defaultHostGroupAccountUserAttachment", new()
    {
        InstanceId = defaultHost.InstanceId,
        UserId = localUser.UserId,
        HostGroupId = defaultHostGroup.HostGroupId,
        HostAccountNames = new[]
        {
            defaultHostAccount.HostAccountName,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.AlicloudFunctions;
import com.pulumi.alicloud.inputs.GetZonesArgs;
import com.pulumi.alicloud.vpc.VpcFunctions;
import com.pulumi.alicloud.vpc.inputs.GetNetworksArgs;
import com.pulumi.alicloud.vpc.inputs.GetSwitchesArgs;
import com.pulumi.alicloud.ecs.SecurityGroup;
import com.pulumi.alicloud.ecs.SecurityGroupArgs;
import com.pulumi.alicloud.bastionhost.Instance;
import com.pulumi.alicloud.bastionhost.InstanceArgs;
import com.pulumi.alicloud.bastionhost.User;
import com.pulumi.alicloud.bastionhost.UserArgs;
import com.pulumi.alicloud.bastionhost.Host;
import com.pulumi.alicloud.bastionhost.HostArgs;
import com.pulumi.alicloud.bastionhost.HostAccount;
import com.pulumi.alicloud.bastionhost.HostAccountArgs;
import com.pulumi.alicloud.bastionhost.HostGroup;
import com.pulumi.alicloud.bastionhost.HostGroupArgs;
import com.pulumi.alicloud.bastionhost.HostGroupAccountUserAttachment;
import com.pulumi.alicloud.bastionhost.HostGroupAccountUserAttachmentArgs;
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) {
        final var config = ctx.config();
        final var name = config.get("name").orElse("tf_example");
        final var defaultZones = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableResourceCreation("VSwitch")
            .build());

        final var defaultNetworks = VpcFunctions.getNetworks(GetNetworksArgs.builder()
            .nameRegex("^default-NODELETING$")
            .cidrBlock("10.4.0.0/16")
            .build());

        final var defaultSwitches = VpcFunctions.getSwitches(GetSwitchesArgs.builder()
            .cidrBlock("10.4.0.0/24")
            .vpcId(defaultNetworks.applyValue(getNetworksResult -> getNetworksResult.ids()[0]))
            .zoneId(defaultZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .build());

        var defaultSecurityGroup = new SecurityGroup("defaultSecurityGroup", SecurityGroupArgs.builder()        
            .vpcId(defaultNetworks.applyValue(getNetworksResult -> getNetworksResult.ids()[0]))
            .build());

        var defaultInstance = new Instance("defaultInstance", InstanceArgs.builder()        
            .description(name)
            .licenseCode("bhah_ent_50_asset")
            .planCode("cloudbastion")
            .storage("5")
            .bandwidth("5")
            .period("1")
            .vswitchId(defaultSwitches.applyValue(getSwitchesResult -> getSwitchesResult.ids()[0]))
            .securityGroupIds(defaultSecurityGroup.id())
            .build());

        var localUser = new User("localUser", UserArgs.builder()        
            .instanceId(defaultInstance.id())
            .mobileCountryCode("CN")
            .mobile("13312345678")
            .password("YourPassword-123")
            .source("Local")
            .userName(String.format("%s_local_user", name))
            .build());

        var defaultHost = new Host("defaultHost", HostArgs.builder()        
            .instanceId(defaultInstance.id())
            .hostName(name)
            .activeAddressType("Private")
            .hostPrivateAddress("172.16.0.10")
            .osType("Linux")
            .source("Local")
            .build());

        var defaultHostAccount = new HostAccount("defaultHostAccount", HostAccountArgs.builder()        
            .hostAccountName(name)
            .hostId(defaultHost.hostId())
            .instanceId(defaultHost.instanceId())
            .protocolName("SSH")
            .password("YourPassword12345")
            .build());

        var defaultHostGroup = new HostGroup("defaultHostGroup", HostGroupArgs.builder()        
            .hostGroupName(name)
            .instanceId(defaultInstance.id())
            .build());

        var defaultHostGroupAccountUserAttachment = new HostGroupAccountUserAttachment("defaultHostGroupAccountUserAttachment", HostGroupAccountUserAttachmentArgs.builder()        
            .instanceId(defaultHost.instanceId())
            .userId(localUser.userId())
            .hostGroupId(defaultHostGroup.hostGroupId())
            .hostAccountNames(defaultHostAccount.hostAccountName())
            .build());

    }
}

configuration:
  name:
    type: string
    default: tf_example
resources:
  defaultSecurityGroup:
    type: alicloud:ecs:SecurityGroup
    properties:
      vpcId: ${defaultNetworks.ids[0]}
  defaultInstance:
    type: alicloud:bastionhost:Instance
    properties:
      description: ${name}
      licenseCode: bhah_ent_50_asset
      planCode: cloudbastion
      storage: '5'
      bandwidth: '5'
      period: '1'
      vswitchId: ${defaultSwitches.ids[0]}
      securityGroupIds:
        - ${defaultSecurityGroup.id}
  localUser:
    type: alicloud:bastionhost:User
    properties:
      instanceId: ${defaultInstance.id}
      mobileCountryCode: CN
      mobile: '13312345678'
      password: YourPassword-123
      source: Local
      userName: ${name}_local_user
  defaultHost:
    type: alicloud:bastionhost:Host
    properties:
      instanceId: ${defaultInstance.id}
      hostName: ${name}
      activeAddressType: Private
      hostPrivateAddress: 172.16.0.10
      osType: Linux
      source: Local
  defaultHostAccount:
    type: alicloud:bastionhost:HostAccount
    properties:
      hostAccountName: ${name}
      hostId: ${defaultHost.hostId}
      instanceId: ${defaultHost.instanceId}
      protocolName: SSH
      password: YourPassword12345
  defaultHostGroup:
    type: alicloud:bastionhost:HostGroup
    properties:
      hostGroupName: ${name}
      instanceId: ${defaultInstance.id}
  defaultHostGroupAccountUserAttachment:
    type: alicloud:bastionhost:HostGroupAccountUserAttachment
    properties:
      instanceId: ${defaultHost.instanceId}
      userId: ${localUser.userId}
      hostGroupId: ${defaultHostGroup.hostGroupId}
      hostAccountNames:
        - ${defaultHostAccount.hostAccountName}
variables:
  defaultZones:
    fn::invoke:
      Function: alicloud:getZones
      Arguments:
        availableResourceCreation: VSwitch
  defaultNetworks:
    fn::invoke:
      Function: alicloud:vpc:getNetworks
      Arguments:
        nameRegex: ^default-NODELETING$
        cidrBlock: 10.4.0.0/16
  defaultSwitches:
    fn::invoke:
      Function: alicloud:vpc:getSwitches
      Arguments:
        cidrBlock: 10.4.0.0/24
        vpcId: ${defaultNetworks.ids[0]}
        zoneId: ${defaultZones.zones[0].id}

var hostGroupAccountUserAttachmentResource = new AliCloud.BastionHost.HostGroupAccountUserAttachment("hostGroupAccountUserAttachmentResource", new()
{
    HostAccountNames = new[]
    {
        "string",
    },
    HostGroupId = "string",
    InstanceId = "string",
    UserId = "string",
});

example, err := bastionhost.NewHostGroupAccountUserAttachment(ctx, "hostGroupAccountUserAttachmentResource", &bastionhost.HostGroupAccountUserAttachmentArgs{
	HostAccountNames: pulumi.StringArray{
		pulumi.String("string"),
	},
	HostGroupId: pulumi.String("string"),
	InstanceId:  pulumi.String("string"),
	UserId:      pulumi.String("string"),
})

var hostGroupAccountUserAttachmentResource = new HostGroupAccountUserAttachment("hostGroupAccountUserAttachmentResource", HostGroupAccountUserAttachmentArgs.builder()        
    .hostAccountNames("string")
    .hostGroupId("string")
    .instanceId("string")
    .userId("string")
    .build());

host_group_account_user_attachment_resource = alicloud.bastionhost.HostGroupAccountUserAttachment("hostGroupAccountUserAttachmentResource",
    host_account_names=["string"],
    host_group_id="string",
    instance_id="string",
    user_id="string")

const hostGroupAccountUserAttachmentResource = new alicloud.bastionhost.HostGroupAccountUserAttachment("hostGroupAccountUserAttachmentResource", {
    hostAccountNames: ["string"],
    hostGroupId: "string",
    instanceId: "string",
    userId: "string",
});

type: alicloud:bastionhost:HostGroupAccountUserAttachment
properties:
    hostAccountNames:
        - string
    hostGroupId: string
    instanceId: string
    userId: string