alicloud.arms.getAlertRobots

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

const _default = new alicloud.arms.AlertRobot("default", {
    alertRobotName: "my-AlertRobot",
    robotType: "wechat",
    robotAddr: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=1c704e23",
});
const nameRegex = alicloud.arms.getAlertRobotsOutput({
    alertRobotName: _default.alertRobotName,
});
export const armsAlertRobotId = nameRegex.apply(nameRegex => nameRegex.robots?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

default = alicloud.arms.AlertRobot("default",
    alert_robot_name="my-AlertRobot",
    robot_type="wechat",
    robot_addr="https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=1c704e23")
name_regex = alicloud.arms.get_alert_robots_output(alert_robot_name=default.alert_robot_name)
pulumi.export("armsAlertRobotId", name_regex.robots[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/arms"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := arms.NewAlertRobot(ctx, "default", &arms.AlertRobotArgs{
			AlertRobotName: pulumi.String("my-AlertRobot"),
			RobotType:      pulumi.String("wechat"),
			RobotAddr:      pulumi.String("https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=1c704e23"),
		})
		if err != nil {
			return err
		}
		nameRegex := arms.GetAlertRobotsOutput(ctx, arms.GetAlertRobotsOutputArgs{
			AlertRobotName: _default.AlertRobotName,
		}, nil)
		ctx.Export("armsAlertRobotId", nameRegex.ApplyT(func(nameRegex arms.GetAlertRobotsResult) (*string, error) {
			return &nameRegex.Robots[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @default = new AliCloud.Arms.AlertRobot("default", new()
    {
        AlertRobotName = "my-AlertRobot",
        RobotType = "wechat",
        RobotAddr = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=1c704e23",
    });

    var nameRegex = AliCloud.Arms.GetAlertRobots.Invoke(new()
    {
        AlertRobotName = @default.AlertRobotName,
    });

    return new Dictionary<string, object?>
    {
        ["armsAlertRobotId"] = nameRegex.Apply(getAlertRobotsResult => getAlertRobotsResult.Robots[0]?.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.arms.AlertRobot;
import com.pulumi.alicloud.arms.AlertRobotArgs;
import com.pulumi.alicloud.arms.ArmsFunctions;
import com.pulumi.alicloud.arms.inputs.GetAlertRobotsArgs;
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) {
        var default_ = new AlertRobot("default", AlertRobotArgs.builder()
            .alertRobotName("my-AlertRobot")
            .robotType("wechat")
            .robotAddr("https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=1c704e23")
            .build());

        final var nameRegex = ArmsFunctions.getAlertRobots(GetAlertRobotsArgs.builder()
            .alertRobotName(default_.alertRobotName())
            .build());

        ctx.export("armsAlertRobotId", nameRegex.applyValue(getAlertRobotsResult -> getAlertRobotsResult).applyValue(nameRegex -> nameRegex.applyValue(getAlertRobotsResult -> getAlertRobotsResult.robots()[0].id())));
    }
}

resources:
  default:
    type: alicloud:arms:AlertRobot
    properties:
      alertRobotName: my-AlertRobot
      robotType: wechat
      robotAddr: https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=1c704e23
variables:
  nameRegex:
    fn::invoke:
      function: alicloud:arms:getAlertRobots
      arguments:
        alertRobotName: ${default.alertRobotName}
outputs:
  armsAlertRobotId: ${nameRegex.robots[0].id}

function getAlertRobots(args: GetAlertRobotsArgs, opts?: InvokeOptions): Promise<GetAlertRobotsResult>
function getAlertRobotsOutput(args: GetAlertRobotsOutputArgs, opts?: InvokeOptions): Output<GetAlertRobotsResult>

def get_alert_robots(alert_robot_name: Optional[str] = None,
                     ids: Optional[Sequence[str]] = None,
                     name_regex: Optional[str] = None,
                     output_file: Optional[str] = None,
                     robot_type: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetAlertRobotsResult
def get_alert_robots_output(alert_robot_name: Optional[pulumi.Input[str]] = None,
                     ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                     name_regex: Optional[pulumi.Input[str]] = None,
                     output_file: Optional[pulumi.Input[str]] = None,
                     robot_type: Optional[pulumi.Input[str]] = None,
                     opts: Optional[InvokeOptions] = None) -> Output[GetAlertRobotsResult]

func GetAlertRobots(ctx *Context, args *GetAlertRobotsArgs, opts ...InvokeOption) (*GetAlertRobotsResult, error)
func GetAlertRobotsOutput(ctx *Context, args *GetAlertRobotsOutputArgs, opts ...InvokeOption) GetAlertRobotsResultOutput

public static class GetAlertRobots 
{
    public static Task<GetAlertRobotsResult> InvokeAsync(GetAlertRobotsArgs args, InvokeOptions? opts = null)
    public static Output<GetAlertRobotsResult> Invoke(GetAlertRobotsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAlertRobotsResult> getAlertRobots(GetAlertRobotsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: alicloud:arms/getAlertRobots:getAlertRobots
  arguments:
    # arguments dictionary