alicloud.sae.getConfigMaps

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var configMapName = config.Get("configMapName") ?? "examplename";
    var exampleNamespace = new AliCloud.Sae.Namespace("exampleNamespace", new()
    {
        NamespaceId = "cn-hangzhou:yourname",
        NamespaceName = "example_value",
        NamespaceDescription = "your_description",
    });

    var exampleConfigMap = new AliCloud.Sae.ConfigMap("exampleConfigMap", new()
    {
        Data = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["env.home"] = "/root",
            ["env.shell"] = "/bin/sh",
        }),
        NamespaceId = exampleNamespace.NamespaceId,
    });

    var nameRegex = AliCloud.Sae.GetConfigMaps.Invoke(new()
    {
        NamespaceId = exampleNamespace.NamespaceId,
        NameRegex = "^example",
    });

    return new Dictionary<string, object?>
    {
        ["saeConfigMapId"] = nameRegex.Apply(getConfigMapsResult => getConfigMapsResult.Maps[0]?.Id),
    };
});

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/sae"
	"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, "")
		configMapName := "examplename"
		if param := cfg.Get("configMapName"); param != "" {
			configMapName = param
		}
		exampleNamespace, err := sae.NewNamespace(ctx, "exampleNamespace", &sae.NamespaceArgs{
			NamespaceId:          pulumi.String("cn-hangzhou:yourname"),
			NamespaceName:        pulumi.String("example_value"),
			NamespaceDescription: pulumi.String("your_description"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"env.home":  "/root",
			"env.shell": "/bin/sh",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = sae.NewConfigMap(ctx, "exampleConfigMap", &sae.ConfigMapArgs{
			Data:        pulumi.String(json0),
			NamespaceId: exampleNamespace.NamespaceId,
		})
		if err != nil {
			return err
		}
		nameRegex := sae.GetConfigMapsOutput(ctx, sae.GetConfigMapsOutputArgs{
			NamespaceId: exampleNamespace.NamespaceId,
			NameRegex:   pulumi.String("^example"),
		}, nil)
		ctx.Export("saeConfigMapId", nameRegex.ApplyT(func(nameRegex sae.GetConfigMapsResult) (*string, error) {
			return &nameRegex.Maps[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.sae.Namespace;
import com.pulumi.alicloud.sae.NamespaceArgs;
import com.pulumi.alicloud.sae.ConfigMap;
import com.pulumi.alicloud.sae.ConfigMapArgs;
import com.pulumi.alicloud.sae.SaeFunctions;
import com.pulumi.alicloud.sae.inputs.GetConfigMapsArgs;
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 configMapName = config.get("configMapName").orElse("examplename");
        var exampleNamespace = new Namespace("exampleNamespace", NamespaceArgs.builder()        
            .namespaceId("cn-hangzhou:yourname")
            .namespaceName("example_value")
            .namespaceDescription("your_description")
            .build());

        var exampleConfigMap = new ConfigMap("exampleConfigMap", ConfigMapArgs.builder()        
            .data(serializeJson(
                jsonObject(
                    jsonProperty("env.home", "/root"),
                    jsonProperty("env.shell", "/bin/sh")
                )))
            .namespaceId(exampleNamespace.namespaceId())
            .build());

        final var nameRegex = SaeFunctions.getConfigMaps(GetConfigMapsArgs.builder()
            .namespaceId(exampleNamespace.namespaceId())
            .nameRegex("^example")
            .build());

        ctx.export("saeConfigMapId", nameRegex.applyValue(getConfigMapsResult -> getConfigMapsResult).applyValue(nameRegex -> nameRegex.applyValue(getConfigMapsResult -> getConfigMapsResult.maps()[0].id())));
    }
}

import pulumi
import json
import pulumi_alicloud as alicloud

config = pulumi.Config()
config_map_name = config.get("configMapName")
if config_map_name is None:
    config_map_name = "examplename"
example_namespace = alicloud.sae.Namespace("exampleNamespace",
    namespace_id="cn-hangzhou:yourname",
    namespace_name="example_value",
    namespace_description="your_description")
example_config_map = alicloud.sae.ConfigMap("exampleConfigMap",
    data=json.dumps({
        "env.home": "/root",
        "env.shell": "/bin/sh",
    }),
    namespace_id=example_namespace.namespace_id)
name_regex = alicloud.sae.get_config_maps_output(namespace_id=example_namespace.namespace_id,
    name_regex="^example")
pulumi.export("saeConfigMapId", name_regex.maps[0].id)

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

const config = new pulumi.Config();
const configMapName = config.get("configMapName") || "examplename";
const exampleNamespace = new alicloud.sae.Namespace("exampleNamespace", {
    namespaceId: "cn-hangzhou:yourname",
    namespaceName: "example_value",
    namespaceDescription: "your_description",
});
const exampleConfigMap = new alicloud.sae.ConfigMap("exampleConfigMap", {
    data: JSON.stringify({
        "env.home": "/root",
        "env.shell": "/bin/sh",
    }),
    namespaceId: exampleNamespace.namespaceId,
});
const nameRegex = alicloud.sae.getConfigMapsOutput({
    namespaceId: exampleNamespace.namespaceId,
    nameRegex: "^example",
});
export const saeConfigMapId = nameRegex.apply(nameRegex => nameRegex.maps?.[0]?.id);

configuration:
  configMapName:
    type: string
    default: examplename
resources:
  exampleNamespace:
    type: alicloud:sae:Namespace
    properties:
      namespaceId: cn-hangzhou:yourname
      namespaceName: example_value
      namespaceDescription: your_description
  exampleConfigMap:
    type: alicloud:sae:ConfigMap
    properties:
      data:
        fn::toJSON:
          env.home: /root
          env.shell: /bin/sh
      namespaceId: ${exampleNamespace.namespaceId}
variables:
  nameRegex:
    fn::invoke:
      Function: alicloud:sae:getConfigMaps
      Arguments:
        namespaceId: ${exampleNamespace.namespaceId}
        nameRegex: ^example
outputs:
  saeConfigMapId: ${nameRegex.maps[0].id}