tencentcloud.TcrVpcAttachment

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

const vpc = tencentcloud.getVpcSubnets({
    isDefault: true,
    availabilityZone: _var.availability_zone,
});
const vpcId = vpc.then(vpc => vpc.instanceLists?.[0]?.vpcId);
const subnetId = vpc.then(vpc => vpc.instanceLists?.[0]?.subnetId);
const example = new tencentcloud.TcrInstance("example", {
    instanceType: "basic",
    deleteBucket: true,
    tags: {
        createdBy: "terraform",
    },
});
const tcrId = example.tcrInstanceId;
const sg = tencentcloud.getSecurityGroups({
    name: "default",
});
const foo = new tencentcloud.TcrVpcAttachment("foo", {
    instanceId: tcrId,
    vpcId: vpcId,
    subnetId: subnetId,
});

import pulumi
import pulumi_tencentcloud as tencentcloud

vpc = tencentcloud.get_vpc_subnets(is_default=True,
    availability_zone=var["availability_zone"])
vpc_id = vpc.instance_lists[0].vpc_id
subnet_id = vpc.instance_lists[0].subnet_id
example = tencentcloud.TcrInstance("example",
    instance_type="basic",
    delete_bucket=True,
    tags={
        "createdBy": "terraform",
    })
tcr_id = example.tcr_instance_id
sg = tencentcloud.get_security_groups(name="default")
foo = tencentcloud.TcrVpcAttachment("foo",
    instance_id=tcr_id,
    vpc_id=vpc_id,
    subnet_id=subnet_id)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/tencentcloud/tencentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		vpc, err := tencentcloud.GetVpcSubnets(ctx, &tencentcloud.GetVpcSubnetsArgs{
			IsDefault:        pulumi.BoolRef(true),
			AvailabilityZone: pulumi.StringRef(_var.Availability_zone),
		}, nil)
		if err != nil {
			return err
		}
		vpcId := vpc.InstanceLists[0].VpcId
		subnetId := vpc.InstanceLists[0].SubnetId
		example, err := tencentcloud.NewTcrInstance(ctx, "example", &tencentcloud.TcrInstanceArgs{
			InstanceType: pulumi.String("basic"),
			DeleteBucket: pulumi.Bool(true),
			Tags: pulumi.StringMap{
				"createdBy": pulumi.String("terraform"),
			},
		})
		if err != nil {
			return err
		}
		tcrId := example.TcrInstanceId
		_, err = tencentcloud.GetSecurityGroups(ctx, &tencentcloud.GetSecurityGroupsArgs{
			Name: pulumi.StringRef("default"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = tencentcloud.NewTcrVpcAttachment(ctx, "foo", &tencentcloud.TcrVpcAttachmentArgs{
			InstanceId: pulumi.String(tcrId),
			VpcId:      pulumi.String(vpcId),
			SubnetId:   pulumi.String(subnetId),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var vpc = Tencentcloud.GetVpcSubnets.Invoke(new()
    {
        IsDefault = true,
        AvailabilityZone = @var.Availability_zone,
    });

    var vpcId = vpc.Apply(getVpcSubnetsResult => getVpcSubnetsResult.InstanceLists[0]?.VpcId);

    var subnetId = vpc.Apply(getVpcSubnetsResult => getVpcSubnetsResult.InstanceLists[0]?.SubnetId);

    var example = new Tencentcloud.TcrInstance("example", new()
    {
        InstanceType = "basic",
        DeleteBucket = true,
        Tags = 
        {
            { "createdBy", "terraform" },
        },
    });

    var tcrId = example.TcrInstanceId;

    var sg = Tencentcloud.GetSecurityGroups.Invoke(new()
    {
        Name = "default",
    });

    var foo = new Tencentcloud.TcrVpcAttachment("foo", new()
    {
        InstanceId = tcrId,
        VpcId = vpcId,
        SubnetId = subnetId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.tencentcloud.TencentcloudFunctions;
import com.pulumi.tencentcloud.inputs.GetVpcSubnetsArgs;
import com.pulumi.tencentcloud.TcrInstance;
import com.pulumi.tencentcloud.TcrInstanceArgs;
import com.pulumi.tencentcloud.inputs.GetSecurityGroupsArgs;
import com.pulumi.tencentcloud.TcrVpcAttachment;
import com.pulumi.tencentcloud.TcrVpcAttachmentArgs;
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 vpc = TencentcloudFunctions.getVpcSubnets(GetVpcSubnetsArgs.builder()
            .isDefault(true)
            .availabilityZone(var_.availability_zone())
            .build());

        final var vpcId = vpc.applyValue(getVpcSubnetsResult -> getVpcSubnetsResult.instanceLists()[0].vpcId());

        final var subnetId = vpc.applyValue(getVpcSubnetsResult -> getVpcSubnetsResult.instanceLists()[0].subnetId());

        var example = new TcrInstance("example", TcrInstanceArgs.builder()
            .instanceType("basic")
            .deleteBucket(true)
            .tags(Map.of("createdBy", "terraform"))
            .build());

        final var tcrId = example.tcrInstanceId();

        final var sg = TencentcloudFunctions.getSecurityGroups(GetSecurityGroupsArgs.builder()
            .name("default")
            .build());

        var foo = new TcrVpcAttachment("foo", TcrVpcAttachmentArgs.builder()
            .instanceId(tcrId)
            .vpcId(vpcId)
            .subnetId(subnetId)
            .build());

    }
}

resources:
  example:
    type: tencentcloud:TcrInstance
    properties:
      instanceType: basic
      deleteBucket: true
      tags:
        createdBy: terraform
  foo:
    type: tencentcloud:TcrVpcAttachment
    properties:
      instanceId: ${tcrId}
      vpcId: ${vpcId}
      subnetId: ${subnetId}
variables:
  vpcId: ${vpc.instanceLists[0].vpcId}
  subnetId: ${vpc.instanceLists[0].subnetId}
  tcrId: ${example.tcrInstanceId}
  vpc:
    fn::invoke:
      function: tencentcloud:getVpcSubnets
      arguments:
        isDefault: true
        availabilityZone: ${var.availability_zone}
  sg:
    fn::invoke:
      function: tencentcloud:getSecurityGroups
      arguments:
        name: default