alicloud.sls.getIndexs

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 logstoreName = config.get("logstoreName") || "logstore-example-1";
const projectName = config.get("projectName") || "project-for-index-terraform-example-1";
const defaultProject = new alicloud.log.Project("default", {
    description: "terraform example",
    projectName: projectName,
});
const defaultStore = new alicloud.log.Store("default", {
    hotTtl: 7,
    retentionPeriod: 30,
    shardCount: 2,
    projectName: defaultProject.projectName,
    logstoreName: logstoreName,
});
const defaultIndex = new alicloud.sls.Index("default", {
    line: {
        chn: true,
        caseSensitive: true,
        tokens: ["a"],
        excludeKeys: ["t"],
    },
    keys: JSON.stringify({
        example: {
            caseSensitive: false,
            token: [
                "\n",
                "\x09",
                ",",
                " ",
                ";",
                "\"",
                "'",
                "(",
                ")",
                "{",
                "}",
                "[",
                "]",
                "<",
                ">",
                "?",
                "/",
                "#",
                ":",
            ],
            type: "text",
            doc_value: false,
            alias: "",
            chn: false,
        },
    }),
    logstoreName: defaultStore.logstoreName,
    projectName: projectName,
});
const _default = alicloud.sls.getIndexsOutput({
    logstoreName: defaultStore.logstoreName,
    projectName: defaultProject.projectName,
});
export const alicloudSlsIndexExampleId = _default.apply(_default => _default.indexs?.[0]?.id);

import pulumi
import json
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
logstore_name = config.get("logstoreName")
if logstore_name is None:
    logstore_name = "logstore-example-1"
project_name = config.get("projectName")
if project_name is None:
    project_name = "project-for-index-terraform-example-1"
default_project = alicloud.log.Project("default",
    description="terraform example",
    project_name=project_name)
default_store = alicloud.log.Store("default",
    hot_ttl=7,
    retention_period=30,
    shard_count=2,
    project_name=default_project.project_name,
    logstore_name=logstore_name)
default_index = alicloud.sls.Index("default",
    line={
        "chn": True,
        "case_sensitive": True,
        "tokens": ["a"],
        "exclude_keys": ["t"],
    },
    keys=json.dumps({
        "example": {
            "caseSensitive": False,
            "token": [
                "\n",
                "\x09",
                ",",
                " ",
                ";",
                "\"",
                "'",
                "(",
                ")",
                "{",
                "}",
                "[",
                "]",
                "<",
                ">",
                "?",
                "/",
                "#",
                ":",
            ],
            "type": "text",
            "doc_value": False,
            "alias": "",
            "chn": False,
        },
    }),
    logstore_name=default_store.logstore_name,
    project_name=project_name)
default = alicloud.sls.get_indexs_output(logstore_name=default_store.logstore_name,
    project_name=default_project.project_name)
pulumi.export("alicloudSlsIndexExampleId", default.indexs[0].id)

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/log"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/sls"
	"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
}
logstoreName := "logstore-example-1";
if param := cfg.Get("logstoreName"); param != ""{
logstoreName = param
}
projectName := "project-for-index-terraform-example-1";
if param := cfg.Get("projectName"); param != ""{
projectName = param
}
defaultProject, err := log.NewProject(ctx, "default", &log.ProjectArgs{
Description: pulumi.String("terraform example"),
ProjectName: pulumi.String(projectName),
})
if err != nil {
return err
}
defaultStore, err := log.NewStore(ctx, "default", &log.StoreArgs{
HotTtl: pulumi.Int(7),
RetentionPeriod: pulumi.Int(30),
ShardCount: pulumi.Int(2),
ProjectName: defaultProject.ProjectName,
LogstoreName: pulumi.String(logstoreName),
})
if err != nil {
return err
}
tmpJSON0, err := json.Marshal(map[string]interface{}{
"example": map[string]interface{}{
"caseSensitive": false,
"token": []string{
"\n",
"	",
",",
" ",
";",
"\"",
"'",
"(",
")",
"{",
"}",
"[",
"]",
"<",
">",
"?",
"/",
"#",
":",
},
"type": "text",
"doc_value": false,
"alias": "",
"chn": false,
},
})
if err != nil {
return err
}
json0 := string(tmpJSON0)
_, err = sls.NewIndex(ctx, "default", &sls.IndexArgs{
Line: &sls.IndexLineArgs{
Chn: pulumi.Bool(true),
CaseSensitive: pulumi.Bool(true),
Tokens: pulumi.StringArray{
pulumi.String("a"),
},
ExcludeKeys: pulumi.StringArray{
pulumi.String("t"),
},
},
Keys: pulumi.String(json0),
LogstoreName: defaultStore.LogstoreName,
ProjectName: pulumi.String(projectName),
})
if err != nil {
return err
}
_default := sls.GetIndexsOutput(ctx, sls.GetIndexsOutputArgs{
LogstoreName: defaultStore.LogstoreName,
ProjectName: defaultProject.ProjectName,
}, nil);
ctx.Export("alicloudSlsIndexExampleId", _default.ApplyT(func(_default sls.GetIndexsResult) (*string, error) {
return &default.Indexs[0].Id, nil
}).(pulumi.StringPtrOutput))
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 logstoreName = config.Get("logstoreName") ?? "logstore-example-1";
    var projectName = config.Get("projectName") ?? "project-for-index-terraform-example-1";
    var defaultProject = new AliCloud.Log.Project("default", new()
    {
        Description = "terraform example",
        ProjectName = projectName,
    });

    var defaultStore = new AliCloud.Log.Store("default", new()
    {
        HotTtl = 7,
        RetentionPeriod = 30,
        ShardCount = 2,
        ProjectName = defaultProject.ProjectName,
        LogstoreName = logstoreName,
    });

    var defaultIndex = new AliCloud.Sls.Index("default", new()
    {
        Line = new AliCloud.Sls.Inputs.IndexLineArgs
        {
            Chn = true,
            CaseSensitive = true,
            Tokens = new[]
            {
                "a",
            },
            ExcludeKeys = new[]
            {
                "t",
            },
        },
        Keys = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["example"] = new Dictionary<string, object?>
            {
                ["caseSensitive"] = false,
                ["token"] = new[]
                {
                    @"
",
                    "	",
                    ",",
                    " ",
                    ";",
                    "\"",
                    "'",
                    "(",
                    ")",
                    "{",
                    "}",
                    "[",
                    "]",
                    "<",
                    ">",
                    "?",
                    "/",
                    "#",
                    ":",
                },
                ["type"] = "text",
                ["doc_value"] = false,
                ["alias"] = "",
                ["chn"] = false,
            },
        }),
        LogstoreName = defaultStore.LogstoreName,
        ProjectName = projectName,
    });

    var @default = AliCloud.Sls.GetIndexs.Invoke(new()
    {
        LogstoreName = defaultStore.LogstoreName,
        ProjectName = defaultProject.ProjectName,
    });

    return new Dictionary<string, object?>
    {
        ["alicloudSlsIndexExampleId"] = @default.Apply(@default => @default.Apply(getIndexsResult => getIndexsResult.Indexs[0]?.Id)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.log.Project;
import com.pulumi.alicloud.log.ProjectArgs;
import com.pulumi.alicloud.log.Store;
import com.pulumi.alicloud.log.StoreArgs;
import com.pulumi.alicloud.sls.Index;
import com.pulumi.alicloud.sls.IndexArgs;
import com.pulumi.alicloud.sls.inputs.IndexLineArgs;
import com.pulumi.alicloud.sls.SlsFunctions;
import com.pulumi.alicloud.sls.inputs.GetIndexsArgs;
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 name = config.get("name").orElse("terraform-example");
        final var logstoreName = config.get("logstoreName").orElse("logstore-example-1");
        final var projectName = config.get("projectName").orElse("project-for-index-terraform-example-1");
        var defaultProject = new Project("defaultProject", ProjectArgs.builder()
            .description("terraform example")
            .projectName(projectName)
            .build());

        var defaultStore = new Store("defaultStore", StoreArgs.builder()
            .hotTtl(7)
            .retentionPeriod(30)
            .shardCount(2)
            .projectName(defaultProject.projectName())
            .logstoreName(logstoreName)
            .build());

        var defaultIndex = new Index("defaultIndex", IndexArgs.builder()
            .line(IndexLineArgs.builder()
                .chn(true)
                .caseSensitive(true)
                .tokens("a")
                .excludeKeys("t")
                .build())
            .keys(serializeJson(
                jsonObject(
                    jsonProperty("example", jsonObject(
                        jsonProperty("caseSensitive", false),
                        jsonProperty("token", jsonArray(
                            """

                            """, 
                            "	", 
                            ",", 
                            " ", 
                            ";", 
                            "\"", 
                            "'", 
                            "(", 
                            ")", 
                            "{", 
                            "}", 
                            "[", 
                            "]", 
                            "<", 
                            ">", 
                            "?", 
                            "/", 
                            "#", 
                            ":"
                        )),
                        jsonProperty("type", "text"),
                        jsonProperty("doc_value", false),
                        jsonProperty("alias", ""),
                        jsonProperty("chn", false)
                    ))
                )))
            .logstoreName(defaultStore.logstoreName())
            .projectName(projectName)
            .build());

        final var default = SlsFunctions.getIndexs(GetIndexsArgs.builder()
            .logstoreName(defaultStore.logstoreName())
            .projectName(defaultProject.projectName())
            .build());

        ctx.export("alicloudSlsIndexExampleId", default_.applyValue(_default_ -> _default_.indexs()[0].id()));
    }
}

configuration:
  name:
    type: string
    default: terraform-example
  logstoreName:
    type: string
    default: logstore-example-1
  projectName:
    type: string
    default: project-for-index-terraform-example-1
resources:
  defaultProject:
    type: alicloud:log:Project
    name: default
    properties:
      description: terraform example
      projectName: ${projectName}
  defaultStore:
    type: alicloud:log:Store
    name: default
    properties:
      hotTtl: '7'
      retentionPeriod: '30'
      shardCount: '2'
      projectName: ${defaultProject.projectName}
      logstoreName: ${logstoreName}
  defaultIndex:
    type: alicloud:sls:Index
    name: default
    properties:
      line:
        chn: 'true'
        caseSensitive: 'true'
        tokens:
          - a
        excludeKeys:
          - t
      keys:
        fn::toJSON:
          example:
            caseSensitive: false
            token:
              - |2+
              - "\t"
              - ','
              - ' '
              - ;
              - '"'
              - ''''
              - (
              - )
              - '{'
              - '}'
              - '['
              - ']'
              - <
              - '>'
              - '?'
              - /
              - '#'
              - ':'
            type: text
            doc_value: false
            alias: ""
            chn: false
      logstoreName: ${defaultStore.logstoreName}
      projectName: ${projectName}
variables:
  default:
    fn::invoke:
      function: alicloud:sls:getIndexs
      arguments:
        logstoreName: ${defaultStore.logstoreName}
        projectName: ${defaultProject.projectName}
outputs:
  alicloudSlsIndexExampleId: ${default.indexs[0].id}

function getIndexs(args: GetIndexsArgs, opts?: InvokeOptions): Promise<GetIndexsResult>
function getIndexsOutput(args: GetIndexsOutputArgs, opts?: InvokeOptions): Output<GetIndexsResult>

def get_indexs(ids: Optional[Sequence[str]] = None,
               logstore_name: Optional[str] = None,
               output_file: Optional[str] = None,
               project_name: Optional[str] = None,
               opts: Optional[InvokeOptions] = None) -> GetIndexsResult
def get_indexs_output(ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
               logstore_name: Optional[pulumi.Input[str]] = None,
               output_file: Optional[pulumi.Input[str]] = None,
               project_name: Optional[pulumi.Input[str]] = None,
               opts: Optional[InvokeOptions] = None) -> Output[GetIndexsResult]

func GetIndexs(ctx *Context, args *GetIndexsArgs, opts ...InvokeOption) (*GetIndexsResult, error)
func GetIndexsOutput(ctx *Context, args *GetIndexsOutputArgs, opts ...InvokeOption) GetIndexsResultOutput

public static class GetIndexs 
{
    public static Task<GetIndexsResult> InvokeAsync(GetIndexsArgs args, InvokeOptions? opts = null)
    public static Output<GetIndexsResult> Invoke(GetIndexsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetIndexsResult> getIndexs(GetIndexsArgs args, InvokeOptions options)
public static Output<GetIndexsResult> getIndexs(GetIndexsArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:sls/getIndexs:getIndexs
  arguments:
    # arguments dictionary