alicloud.ram.getAccessKeyPolicy

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

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const _default = alicloud.getAccount({});
const defaultUser = new alicloud.ram.User("default", {name: name});
const defaultAccessKey = new alicloud.ram.AccessKey("default", {userName: defaultUser.name});
const defaultAccessKeyPolicy = new alicloud.ram.AccessKeyPolicy("default", {
    userAccessKeyId: defaultAccessKey.id,
    userPrincipalName: pulumi.all([defaultUser.name, _default]).apply(([name, _default]) => `${name}@${_default.id}.onaliyun.com`),
    accessKeyPolicy: JSON.stringify({
        Status: "Active",
        Statements: [{
            Type: "ClassicWhiteList",
            IPList: ["10.0.0.1/32"],
        }],
    }),
});
const defaultGetAccessKeyPolicy = alicloud.ram.getAccessKeyPolicyOutput({
    userAccessKeyId: defaultAccessKeyPolicy.userAccessKeyId,
    userPrincipalName: defaultAccessKeyPolicy.userPrincipalName,
});

import pulumi
import json
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default = alicloud.get_account()
default_user = alicloud.ram.User("default", name=name)
default_access_key = alicloud.ram.AccessKey("default", user_name=default_user.name)
default_access_key_policy = alicloud.ram.AccessKeyPolicy("default",
    user_access_key_id=default_access_key.id,
    user_principal_name=default_user.name.apply(lambda name: f"{name}@{default.id}.onaliyun.com"),
    access_key_policy=json.dumps({
        "Status": "Active",
        "Statements": [{
            "Type": "ClassicWhiteList",
            "IPList": ["10.0.0.1/32"],
        }],
    }))
default_get_access_key_policy = alicloud.ram.get_access_key_policy_output(user_access_key_id=default_access_key_policy.user_access_key_id,
    user_principal_name=default_access_key_policy.user_principal_name)

package main

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ram"
	"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 := "terraform-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		_default, err := alicloud.GetAccount(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		defaultUser, err := ram.NewUser(ctx, "default", &ram.UserArgs{
			Name: pulumi.String(name),
		})
		if err != nil {
			return err
		}
		defaultAccessKey, err := ram.NewAccessKey(ctx, "default", &ram.AccessKeyArgs{
			UserName: defaultUser.Name,
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Status": "Active",
			"Statements": []map[string]interface{}{
				map[string]interface{}{
					"Type": "ClassicWhiteList",
					"IPList": []string{
						"10.0.0.1/32",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		defaultAccessKeyPolicy, err := ram.NewAccessKeyPolicy(ctx, "default", &ram.AccessKeyPolicyArgs{
			UserAccessKeyId: defaultAccessKey.ID().ToIDOutput().ToStringOutput(),
			UserPrincipalName: defaultUser.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("%v@%v.onaliyun.com", name, _default.Id), nil
			}).(pulumi.StringOutput),
			AccessKeyPolicy: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		_ = ram.LookupAccessKeyPolicyOutput(ctx, ram.GetAccessKeyPolicyOutputArgs{
			UserAccessKeyId:   defaultAccessKeyPolicy.UserAccessKeyId,
			UserPrincipalName: defaultAccessKeyPolicy.UserPrincipalName,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var @default = AliCloud.GetAccount.Invoke();

    var defaultUser = new AliCloud.Ram.User("default", new()
    {
        Name = name,
    });

    var defaultAccessKey = new AliCloud.Ram.AccessKey("default", new()
    {
        UserName = defaultUser.Name,
    });

    var defaultAccessKeyPolicy = new AliCloud.Ram.AccessKeyPolicy("default", new()
    {
        UserAccessKeyId = defaultAccessKey.Id,
        UserPrincipalName = Output.Tuple(defaultUser.Name, @default).Apply(values =>
        {
            var name = values.Item1;
            var @default = values.Item2;
            return $"{name}@{@default.Apply(getAccountResult => getAccountResult.Id)}.onaliyun.com";
        }),
        Policy = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Status"] = "Active",
            ["Statements"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Type"] = "ClassicWhiteList",
                    ["IPList"] = new[]
                    {
                        "10.0.0.1/32",
                    },
                },
            },
        }),
    });

    var defaultGetAccessKeyPolicy = AliCloud.Ram.GetAccessKeyPolicy.Invoke(new()
    {
        UserAccessKeyId = defaultAccessKeyPolicy.UserAccessKeyId,
        UserPrincipalName = defaultAccessKeyPolicy.UserPrincipalName,
    });

});

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.ram.User;
import com.pulumi.alicloud.ram.UserArgs;
import com.pulumi.alicloud.ram.AccessKey;
import com.pulumi.alicloud.ram.AccessKeyArgs;
import com.pulumi.alicloud.ram.AccessKeyPolicy;
import com.pulumi.alicloud.ram.AccessKeyPolicyArgs;
import com.pulumi.alicloud.ram.RamFunctions;
import com.pulumi.alicloud.ram.inputs.GetAccessKeyPolicyArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.ArrayList;
import java.util.Arrays;
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("terraform-example");
        final var default = AlicloudFunctions.getAccount(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        var defaultUser = new User("defaultUser", UserArgs.builder()
            .name(name)
            .build());

        var defaultAccessKey = new AccessKey("defaultAccessKey", AccessKeyArgs.builder()
            .userName(defaultUser.name())
            .build());

        var defaultAccessKeyPolicy = new AccessKeyPolicy("defaultAccessKeyPolicy", AccessKeyPolicyArgs.builder()
            .userAccessKeyId(defaultAccessKey.id())
            .userPrincipalName(defaultUser.name().applyValue(_name -> String.format("%s@%s.onaliyun.com", _name,default_.id())))
            .accessKeyPolicy(serializeJson(
                jsonObject(
                    jsonProperty("Status", "Active"),
                    jsonProperty("Statements", jsonArray(jsonObject(
                        jsonProperty("Type", "ClassicWhiteList"),
                        jsonProperty("IPList", jsonArray("10.0.0.1/32"))
                    )))
                )))
            .build());

        final var defaultGetAccessKeyPolicy = RamFunctions.getAccessKeyPolicy(GetAccessKeyPolicyArgs.builder()
            .userAccessKeyId(defaultAccessKeyPolicy.userAccessKeyId())
            .userPrincipalName(defaultAccessKeyPolicy.userPrincipalName())
            .build());

    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultUser:
    type: alicloud:ram:User
    name: default
    properties:
      name: ${name}
  defaultAccessKey:
    type: alicloud:ram:AccessKey
    name: default
    properties:
      userName: ${defaultUser.name}
  defaultAccessKeyPolicy:
    type: alicloud:ram:AccessKeyPolicy
    name: default
    properties:
      userAccessKeyId: ${defaultAccessKey.id}
      userPrincipalName: ${defaultUser.name}@${default.id}.onaliyun.com
      accessKeyPolicy:
        fn::toJSON:
          Status: Active
          Statements:
            - Type: ClassicWhiteList
              IPList:
                - 10.0.0.1/32
variables:
  default:
    fn::invoke:
      function: alicloud:getAccount
      arguments: {}
  defaultGetAccessKeyPolicy:
    fn::invoke:
      function: alicloud:ram:getAccessKeyPolicy
      arguments:
        userAccessKeyId: ${defaultAccessKeyPolicy.userAccessKeyId}
        userPrincipalName: ${defaultAccessKeyPolicy.userPrincipalName}

pulumi {
  required_providers {
    alicloud = {
      source = "pulumi/alicloud"
    }
  }
}

data "alicloud_getaccount" "default" {
}
data "alicloud_ram_getaccesskeypolicy" "defaultGetAccessKeyPolicy" {
  user_access_key_id  = alicloud_ram_accesskeypolicy.default.user_access_key_id
  user_principal_name = alicloud_ram_accesskeypolicy.default.user_principal_name
}

resource "alicloud_ram_user" "default" {
  name = var.name
}
resource "alicloud_ram_accesskey" "default" {
  user_name = alicloud_ram_user.default.name
}
resource "alicloud_ram_accesskeypolicy" "default" {
  user_access_key_id  = alicloud_ram_accesskey.default.id
  user_principal_name ="${alicloud_ram_user.default.name}@${data.alicloud_getaccount.default.id}.onaliyun.com"
  access_key_policy = jsonencode({
    "Status" = "Active"
    "Statements" = [{
      "Type"   = "ClassicWhiteList"
      "IPList" = ["10.0.0.1/32"]
    }]
  })
}
variable "name" {
  type    = string
  default = "terraform-example"
}

function getAccessKeyPolicy(args: GetAccessKeyPolicyArgs, opts?: InvokeOptions): Promise<GetAccessKeyPolicyResult>
function getAccessKeyPolicyOutput(args: GetAccessKeyPolicyOutputArgs, opts?: InvokeOutputOptions): Output<GetAccessKeyPolicyResult>

def get_access_key_policy(user_access_key_id: Optional[str] = None,
                          user_principal_name: Optional[str] = None,
                          opts: Optional[InvokeOptions] = None) -> GetAccessKeyPolicyResult
def get_access_key_policy_output(user_access_key_id: pulumi.Input[Optional[str]] = None,
                          user_principal_name: pulumi.Input[Optional[str]] = None,
                          opts: Optional[InvokeOutputOptions] = None) -> Output[GetAccessKeyPolicyResult]

func LookupAccessKeyPolicy(ctx *Context, args *LookupAccessKeyPolicyArgs, opts ...InvokeOption) (*LookupAccessKeyPolicyResult, error)
func LookupAccessKeyPolicyOutput(ctx *Context, args *LookupAccessKeyPolicyOutputArgs, opts ...InvokeOption) LookupAccessKeyPolicyResultOutput

public static class GetAccessKeyPolicy 
{
    public static Task<GetAccessKeyPolicyResult> InvokeAsync(GetAccessKeyPolicyArgs args, InvokeOptions? opts = null)
    public static Output<GetAccessKeyPolicyResult> Invoke(GetAccessKeyPolicyInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetAccessKeyPolicyResult> Invoke(GetAccessKeyPolicyInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetAccessKeyPolicyResult> getAccessKeyPolicy(GetAccessKeyPolicyArgs args, InvokeOptions options)
public static Output<GetAccessKeyPolicyResult> getAccessKeyPolicy(GetAccessKeyPolicyArgs args, InvokeOptions options)
public static Output<GetAccessKeyPolicyResult> getAccessKeyPolicy(GetAccessKeyPolicyArgs args, InvokeOutputOptions options)

fn::invoke:
  function: alicloud:ram/getAccessKeyPolicy:getAccessKeyPolicy
  arguments:
    # arguments dictionary

data "alicloud_ram_get_access_key_policy" "name" {
    # arguments
}