tencentcloud.CamUserPolicyAttachment

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

const config = new pulumi.Config();
const camUserBasic = config.get("camUserBasic") || "keep-cam-user";
const policyBasic = new tencentcloud.CamPolicy("policyBasic", {
    document: JSON.stringify({
        version: "2.0",
        statement: [
            {
                action: ["cos:*"],
                resource: ["*"],
                effect: "allow",
            },
            {
                effect: "allow",
                action: [
                    "monitor:*",
                    "cam:ListUsersForGroup",
                    "cam:ListGroups",
                    "cam:GetGroup",
                ],
                resource: ["*"],
            },
        ],
    }),
    description: "tf_test",
});
const users = tencentcloud.getCamUsers({
    name: camUserBasic,
});
const userPolicyAttachmentBasic = new tencentcloud.CamUserPolicyAttachment("userPolicyAttachmentBasic", {
    userName: users.then(users => users.userLists?.[0]?.userId),
    policyId: policyBasic.camPolicyId,
});

import pulumi
import json
import pulumi_tencentcloud as tencentcloud

config = pulumi.Config()
cam_user_basic = config.get("camUserBasic")
if cam_user_basic is None:
    cam_user_basic = "keep-cam-user"
policy_basic = tencentcloud.CamPolicy("policyBasic",
    document=json.dumps({
        "version": "2.0",
        "statement": [
            {
                "action": ["cos:*"],
                "resource": ["*"],
                "effect": "allow",
            },
            {
                "effect": "allow",
                "action": [
                    "monitor:*",
                    "cam:ListUsersForGroup",
                    "cam:ListGroups",
                    "cam:GetGroup",
                ],
                "resource": ["*"],
            },
        ],
    }),
    description="tf_test")
users = tencentcloud.get_cam_users(name=cam_user_basic)
user_policy_attachment_basic = tencentcloud.CamUserPolicyAttachment("userPolicyAttachmentBasic",
    user_name=users.user_lists[0].user_id,
    policy_id=policy_basic.cam_policy_id)

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/tencentcloud/tencentcloud"
	"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, "")
		camUserBasic := "keep-cam-user"
		if param := cfg.Get("camUserBasic"); param != "" {
			camUserBasic = param
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"version": "2.0",
			"statement": []map[string]interface{}{
				map[string]interface{}{
					"action": []string{
						"cos:*",
					},
					"resource": []string{
						"*",
					},
					"effect": "allow",
				},
				map[string]interface{}{
					"effect": "allow",
					"action": []string{
						"monitor:*",
						"cam:ListUsersForGroup",
						"cam:ListGroups",
						"cam:GetGroup",
					},
					"resource": []string{
						"*",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		policyBasic, err := tencentcloud.NewCamPolicy(ctx, "policyBasic", &tencentcloud.CamPolicyArgs{
			Document:    pulumi.String(json0),
			Description: pulumi.String("tf_test"),
		})
		if err != nil {
			return err
		}
		users, err := tencentcloud.GetCamUsers(ctx, &tencentcloud.GetCamUsersArgs{
			Name: pulumi.StringRef(camUserBasic),
		}, nil)
		if err != nil {
			return err
		}
		_, err = tencentcloud.NewCamUserPolicyAttachment(ctx, "userPolicyAttachmentBasic", &tencentcloud.CamUserPolicyAttachmentArgs{
			UserName: pulumi.String(users.UserLists[0].UserId),
			PolicyId: policyBasic.CamPolicyId,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var camUserBasic = config.Get("camUserBasic") ?? "keep-cam-user";
    var policyBasic = new Tencentcloud.CamPolicy("policyBasic", new()
    {
        Document = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["version"] = "2.0",
            ["statement"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["action"] = new[]
                    {
                        "cos:*",
                    },
                    ["resource"] = new[]
                    {
                        "*",
                    },
                    ["effect"] = "allow",
                },
                new Dictionary<string, object?>
                {
                    ["effect"] = "allow",
                    ["action"] = new[]
                    {
                        "monitor:*",
                        "cam:ListUsersForGroup",
                        "cam:ListGroups",
                        "cam:GetGroup",
                    },
                    ["resource"] = new[]
                    {
                        "*",
                    },
                },
            },
        }),
        Description = "tf_test",
    });

    var users = Tencentcloud.GetCamUsers.Invoke(new()
    {
        Name = camUserBasic,
    });

    var userPolicyAttachmentBasic = new Tencentcloud.CamUserPolicyAttachment("userPolicyAttachmentBasic", new()
    {
        UserName = users.Apply(getCamUsersResult => getCamUsersResult.UserLists[0]?.UserId),
        PolicyId = policyBasic.CamPolicyId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.tencentcloud.CamPolicy;
import com.pulumi.tencentcloud.CamPolicyArgs;
import com.pulumi.tencentcloud.TencentcloudFunctions;
import com.pulumi.tencentcloud.inputs.GetCamUsersArgs;
import com.pulumi.tencentcloud.CamUserPolicyAttachment;
import com.pulumi.tencentcloud.CamUserPolicyAttachmentArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 camUserBasic = config.get("camUserBasic").orElse("keep-cam-user");
        var policyBasic = new CamPolicy("policyBasic", CamPolicyArgs.builder()
            .document(serializeJson(
                jsonObject(
                    jsonProperty("version", "2.0"),
                    jsonProperty("statement", jsonArray(
                        jsonObject(
                            jsonProperty("action", jsonArray("cos:*")),
                            jsonProperty("resource", jsonArray("*")),
                            jsonProperty("effect", "allow")
                        ), 
                        jsonObject(
                            jsonProperty("effect", "allow"),
                            jsonProperty("action", jsonArray(
                                "monitor:*", 
                                "cam:ListUsersForGroup", 
                                "cam:ListGroups", 
                                "cam:GetGroup"
                            )),
                            jsonProperty("resource", jsonArray("*"))
                        )
                    ))
                )))
            .description("tf_test")
            .build());

        final var users = TencentcloudFunctions.getCamUsers(GetCamUsersArgs.builder()
            .name(camUserBasic)
            .build());

        var userPolicyAttachmentBasic = new CamUserPolicyAttachment("userPolicyAttachmentBasic", CamUserPolicyAttachmentArgs.builder()
            .userName(users.applyValue(getCamUsersResult -> getCamUsersResult.userLists()[0].userId()))
            .policyId(policyBasic.camPolicyId())
            .build());

    }
}

configuration:
  camUserBasic:
    type: string
    default: keep-cam-user
resources:
  policyBasic:
    type: tencentcloud:CamPolicy
    properties:
      document:
        fn::toJSON:
          version: '2.0'
          statement:
            - action:
                - cos:*
              resource:
                - '*'
              effect: allow
            - effect: allow
              action:
                - monitor:*
                - cam:ListUsersForGroup
                - cam:ListGroups
                - cam:GetGroup
              resource:
                - '*'
      description: tf_test
  userPolicyAttachmentBasic:
    type: tencentcloud:CamUserPolicyAttachment
    properties:
      userName: ${users.userLists[0].userId}
      policyId: ${policyBasic.camPolicyId}
variables:
  users:
    fn::invoke:
      function: tencentcloud:getCamUsers
      arguments:
        name: ${camUserBasic}