pulumi-alicloud 3.88.0a1761888283__py3-none-any.whl → 3.88.0a1761969289__py3-none-any.whl

pulumi_alicloud/sae/_inputs.py

@@ -367,6 +367,10 @@ if not MYPY:
         """
         Execute. See `exec` below.
         """
+        failure_threshold: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The number of consecutive failures required before considering the container as unhealthy. Increasing this value makes the container more tolerant to transient failures.
+        """
         http_get: NotRequired[pulumi.Input['ApplicationLivenessV2HttpGetArgsDict']]
         """
         The liveness check settings of the container. See `http_get` below.
@@ -394,6 +398,7 @@ elif False:
 class ApplicationLivenessV2Args:
     def __init__(__self__, *,
                  exec_: Optional[pulumi.Input['ApplicationLivenessV2ExecArgs']] = None,
+                 failure_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                  http_get: Optional[pulumi.Input['ApplicationLivenessV2HttpGetArgs']] = None,
                  initial_delay_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                  period_seconds: Optional[pulumi.Input[_builtins.int]] = None,
@@ -401,6 +406,7 @@ class ApplicationLivenessV2Args:
                  timeout_seconds: Optional[pulumi.Input[_builtins.int]] = None):
         """
         :param pulumi.Input['ApplicationLivenessV2ExecArgs'] exec_: Execute. See `exec` below.
+        :param pulumi.Input[_builtins.int] failure_threshold: The number of consecutive failures required before considering the container as unhealthy. Increasing this value makes the container more tolerant to transient failures.
         :param pulumi.Input['ApplicationLivenessV2HttpGetArgs'] http_get: The liveness check settings of the container. See `http_get` below.
         :param pulumi.Input[_builtins.int] initial_delay_seconds: The delay of the health check.
         :param pulumi.Input[_builtins.int] period_seconds: The interval at which the health check is performed.
@@ -409,6 +415,8 @@ class ApplicationLivenessV2Args:
         """
         if exec_ is not None:
             pulumi.set(__self__, "exec_", exec_)
+        if failure_threshold is not None:
+            pulumi.set(__self__, "failure_threshold", failure_threshold)
         if http_get is not None:
             pulumi.set(__self__, "http_get", http_get)
         if initial_delay_seconds is not None:
@@ -432,6 +440,18 @@ class ApplicationLivenessV2Args:
     def exec_(self, value: Optional[pulumi.Input['ApplicationLivenessV2ExecArgs']]):
         pulumi.set(self, "exec_", value)
 
+    @_builtins.property
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of consecutive failures required before considering the container as unhealthy. Increasing this value makes the container more tolerant to transient failures.
+        """
+        return pulumi.get(self, "failure_threshold")
+
+    @failure_threshold.setter
+    def failure_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "failure_threshold", value)
+
     @_builtins.property
     @pulumi.getter(name="httpGet")
     def http_get(self) -> Optional[pulumi.Input['ApplicationLivenessV2HttpGetArgs']]:
@@ -1098,6 +1118,10 @@ if not MYPY:
         """
         Execute. See `exec` below.
         """
+        failure_threshold: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The number of consecutive failures required before considering the container as unhealthy. Increasing this value makes the container more tolerant to transient failures.
+        """
         http_get: NotRequired[pulumi.Input['ApplicationReadinessV2HttpGetArgsDict']]
         """
         The liveness check settings of the container. See `http_get` below.
@@ -1110,6 +1134,10 @@ if not MYPY:
         """
         The interval at which the health check is performed.
         """
+        success_threshold: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The number of consecutive successes required before considering the container as healthy. Increasing this value makes the container more tolerant to transient successes during recovery.
+        """
         tcp_socket: NotRequired[pulumi.Input['ApplicationReadinessV2TcpSocketArgsDict']]
         """
         The liveness check settings of the container. See `tcp_socket` below.
@@ -1125,27 +1153,35 @@ elif False:
 class ApplicationReadinessV2Args:
     def __init__(__self__, *,
                  exec_: Optional[pulumi.Input['ApplicationReadinessV2ExecArgs']] = None,
+                 failure_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                  http_get: Optional[pulumi.Input['ApplicationReadinessV2HttpGetArgs']] = None,
                  initial_delay_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                  period_seconds: Optional[pulumi.Input[_builtins.int]] = None,
+                 success_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                  tcp_socket: Optional[pulumi.Input['ApplicationReadinessV2TcpSocketArgs']] = None,
                  timeout_seconds: Optional[pulumi.Input[_builtins.int]] = None):
         """
         :param pulumi.Input['ApplicationReadinessV2ExecArgs'] exec_: Execute. See `exec` below.
+        :param pulumi.Input[_builtins.int] failure_threshold: The number of consecutive failures required before considering the container as unhealthy. Increasing this value makes the container more tolerant to transient failures.
         :param pulumi.Input['ApplicationReadinessV2HttpGetArgs'] http_get: The liveness check settings of the container. See `http_get` below.
         :param pulumi.Input[_builtins.int] initial_delay_seconds: The delay of the health check.
         :param pulumi.Input[_builtins.int] period_seconds: The interval at which the health check is performed.
+        :param pulumi.Input[_builtins.int] success_threshold: The number of consecutive successes required before considering the container as healthy. Increasing this value makes the container more tolerant to transient successes during recovery.
         :param pulumi.Input['ApplicationReadinessV2TcpSocketArgs'] tcp_socket: The liveness check settings of the container. See `tcp_socket` below.
         :param pulumi.Input[_builtins.int] timeout_seconds: The timeout period of the health check.
         """
         if exec_ is not None:
             pulumi.set(__self__, "exec_", exec_)
+        if failure_threshold is not None:
+            pulumi.set(__self__, "failure_threshold", failure_threshold)
         if http_get is not None:
             pulumi.set(__self__, "http_get", http_get)
         if initial_delay_seconds is not None:
             pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
         if period_seconds is not None:
             pulumi.set(__self__, "period_seconds", period_seconds)
+        if success_threshold is not None:
+            pulumi.set(__self__, "success_threshold", success_threshold)
         if tcp_socket is not None:
             pulumi.set(__self__, "tcp_socket", tcp_socket)
         if timeout_seconds is not None:
@@ -1163,6 +1199,18 @@ class ApplicationReadinessV2Args:
     def exec_(self, value: Optional[pulumi.Input['ApplicationReadinessV2ExecArgs']]):
         pulumi.set(self, "exec_", value)
 
+    @_builtins.property
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of consecutive failures required before considering the container as unhealthy. Increasing this value makes the container more tolerant to transient failures.
+        """
+        return pulumi.get(self, "failure_threshold")
+
+    @failure_threshold.setter
+    def failure_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "failure_threshold", value)
+
     @_builtins.property
     @pulumi.getter(name="httpGet")
     def http_get(self) -> Optional[pulumi.Input['ApplicationReadinessV2HttpGetArgs']]:
@@ -1199,6 +1247,18 @@ class ApplicationReadinessV2Args:
     def period_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
         pulumi.set(self, "period_seconds", value)
 
+    @_builtins.property
+    @pulumi.getter(name="successThreshold")
+    def success_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of consecutive successes required before considering the container as healthy. Increasing this value makes the container more tolerant to transient successes during recovery.
+        """
+        return pulumi.get(self, "success_threshold")
+
+    @success_threshold.setter
+    def success_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "success_threshold", value)
+
     @_builtins.property
     @pulumi.getter(name="tcpSocket")
     def tcp_socket(self) -> Optional[pulumi.Input['ApplicationReadinessV2TcpSocketArgs']]:

pulumi_alicloud/sae/application.py

@@ -3102,7 +3102,7 @@ class Application(pulumi.CustomResource):
 
     @_builtins.property
     @pulumi.getter(name="acrAssumeRoleArn")
-    def acr_assume_role_arn(self) -> pulumi.Output[Optional[_builtins.str]]:
+    def acr_assume_role_arn(self) -> pulumi.Output[_builtins.str]:
         """
         The ARN of the RAM role required when pulling images across accounts. Only necessary if the image_url is pointing to an ACR EE instance.
         """

pulumi_alicloud/sae/outputs.py

@@ -322,6 +322,8 @@ class ApplicationLivenessV2(dict):
         suggest = None
         if key == "exec":
             suggest = "exec_"
+        elif key == "failureThreshold":
+            suggest = "failure_threshold"
         elif key == "httpGet":
             suggest = "http_get"
         elif key == "initialDelaySeconds":
@@ -346,6 +348,7 @@ class ApplicationLivenessV2(dict):
 
     def __init__(__self__, *,
                  exec_: Optional['outputs.ApplicationLivenessV2Exec'] = None,
+                 failure_threshold: Optional[_builtins.int] = None,
                  http_get: Optional['outputs.ApplicationLivenessV2HttpGet'] = None,
                  initial_delay_seconds: Optional[_builtins.int] = None,
                  period_seconds: Optional[_builtins.int] = None,
@@ -353,6 +356,7 @@ class ApplicationLivenessV2(dict):
                  timeout_seconds: Optional[_builtins.int] = None):
         """
         :param 'ApplicationLivenessV2ExecArgs' exec_: Execute. See `exec` below.
+        :param _builtins.int failure_threshold: The number of consecutive failures required before considering the container as unhealthy. Increasing this value makes the container more tolerant to transient failures.
         :param 'ApplicationLivenessV2HttpGetArgs' http_get: The liveness check settings of the container. See `http_get` below.
         :param _builtins.int initial_delay_seconds: The delay of the health check.
         :param _builtins.int period_seconds: The interval at which the health check is performed.
@@ -361,6 +365,8 @@ class ApplicationLivenessV2(dict):
         """
         if exec_ is not None:
             pulumi.set(__self__, "exec_", exec_)
+        if failure_threshold is not None:
+            pulumi.set(__self__, "failure_threshold", failure_threshold)
         if http_get is not None:
             pulumi.set(__self__, "http_get", http_get)
         if initial_delay_seconds is not None:
@@ -380,6 +386,14 @@ class ApplicationLivenessV2(dict):
         """
         return pulumi.get(self, "exec_")
 
+    @_builtins.property
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> Optional[_builtins.int]:
+        """
+        The number of consecutive failures required before considering the container as unhealthy. Increasing this value makes the container more tolerant to transient failures.
+        """
+        return pulumi.get(self, "failure_threshold")
+
     @_builtins.property
     @pulumi.getter(name="httpGet")
     def http_get(self) -> Optional['outputs.ApplicationLivenessV2HttpGet']:
@@ -907,12 +921,16 @@ class ApplicationReadinessV2(dict):
         suggest = None
         if key == "exec":
             suggest = "exec_"
+        elif key == "failureThreshold":
+            suggest = "failure_threshold"
         elif key == "httpGet":
             suggest = "http_get"
         elif key == "initialDelaySeconds":
             suggest = "initial_delay_seconds"
         elif key == "periodSeconds":
             suggest = "period_seconds"
+        elif key == "successThreshold":
+            suggest = "success_threshold"
         elif key == "tcpSocket":
             suggest = "tcp_socket"
         elif key == "timeoutSeconds":
@@ -931,27 +949,35 @@ class ApplicationReadinessV2(dict):
 
     def __init__(__self__, *,
                  exec_: Optional['outputs.ApplicationReadinessV2Exec'] = None,
+                 failure_threshold: Optional[_builtins.int] = None,
                  http_get: Optional['outputs.ApplicationReadinessV2HttpGet'] = None,
                  initial_delay_seconds: Optional[_builtins.int] = None,
                  period_seconds: Optional[_builtins.int] = None,
+                 success_threshold: Optional[_builtins.int] = None,
                  tcp_socket: Optional['outputs.ApplicationReadinessV2TcpSocket'] = None,
                  timeout_seconds: Optional[_builtins.int] = None):
         """
         :param 'ApplicationReadinessV2ExecArgs' exec_: Execute. See `exec` below.
+        :param _builtins.int failure_threshold: The number of consecutive failures required before considering the container as unhealthy. Increasing this value makes the container more tolerant to transient failures.
         :param 'ApplicationReadinessV2HttpGetArgs' http_get: The liveness check settings of the container. See `http_get` below.
         :param _builtins.int initial_delay_seconds: The delay of the health check.
         :param _builtins.int period_seconds: The interval at which the health check is performed.
+        :param _builtins.int success_threshold: The number of consecutive successes required before considering the container as healthy. Increasing this value makes the container more tolerant to transient successes during recovery.
         :param 'ApplicationReadinessV2TcpSocketArgs' tcp_socket: The liveness check settings of the container. See `tcp_socket` below.
         :param _builtins.int timeout_seconds: The timeout period of the health check.
         """
         if exec_ is not None:
             pulumi.set(__self__, "exec_", exec_)
+        if failure_threshold is not None:
+            pulumi.set(__self__, "failure_threshold", failure_threshold)
         if http_get is not None:
             pulumi.set(__self__, "http_get", http_get)
         if initial_delay_seconds is not None:
             pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
         if period_seconds is not None:
             pulumi.set(__self__, "period_seconds", period_seconds)
+        if success_threshold is not None:
+            pulumi.set(__self__, "success_threshold", success_threshold)
         if tcp_socket is not None:
             pulumi.set(__self__, "tcp_socket", tcp_socket)
         if timeout_seconds is not None:
@@ -965,6 +991,14 @@ class ApplicationReadinessV2(dict):
         """
         return pulumi.get(self, "exec_")
 
+    @_builtins.property
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> Optional[_builtins.int]:
+        """
+        The number of consecutive failures required before considering the container as unhealthy. Increasing this value makes the container more tolerant to transient failures.
+        """
+        return pulumi.get(self, "failure_threshold")
+
     @_builtins.property
     @pulumi.getter(name="httpGet")
     def http_get(self) -> Optional['outputs.ApplicationReadinessV2HttpGet']:
@@ -989,6 +1023,14 @@ class ApplicationReadinessV2(dict):
         """
         return pulumi.get(self, "period_seconds")
 
+    @_builtins.property
+    @pulumi.getter(name="successThreshold")
+    def success_threshold(self) -> Optional[_builtins.int]:
+        """
+        The number of consecutive successes required before considering the container as healthy. Increasing this value makes the container more tolerant to transient successes during recovery.
+        """
+        return pulumi.get(self, "success_threshold")
+
     @_builtins.property
     @pulumi.getter(name="tcpSocket")
     def tcp_socket(self) -> Optional['outputs.ApplicationReadinessV2TcpSocket']:

pulumi_alicloud/sls/__init__.py

@@ -11,6 +11,7 @@ from .collection_policy import *
 from .etl import *
 from .get_alerts import *
 from .get_etls import *
+from .get_indexs import *
 from .get_logtail_configs import *
 from .get_machine_groups import *
 from .index import *

pulumi_alicloud/sls/get_indexs.py

@@ -0,0 +1,304 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from .. import _utilities
+from . import outputs
+
+__all__ = [
+    'GetIndexsResult',
+    'AwaitableGetIndexsResult',
+    'get_indexs',
+    'get_indexs_output',
+]
+
+@pulumi.output_type
+class GetIndexsResult:
+    """
+    A collection of values returned by getIndexs.
+    """
+    def __init__(__self__, id=None, ids=None, indexs=None, logstore_name=None, output_file=None, project_name=None):
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if ids and not isinstance(ids, list):
+            raise TypeError("Expected argument 'ids' to be a list")
+        pulumi.set(__self__, "ids", ids)
+        if indexs and not isinstance(indexs, list):
+            raise TypeError("Expected argument 'indexs' to be a list")
+        pulumi.set(__self__, "indexs", indexs)
+        if logstore_name and not isinstance(logstore_name, str):
+            raise TypeError("Expected argument 'logstore_name' to be a str")
+        pulumi.set(__self__, "logstore_name", logstore_name)
+        if output_file and not isinstance(output_file, str):
+            raise TypeError("Expected argument 'output_file' to be a str")
+        pulumi.set(__self__, "output_file", output_file)
+        if project_name and not isinstance(project_name, str):
+            raise TypeError("Expected argument 'project_name' to be a str")
+        pulumi.set(__self__, "project_name", project_name)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter
+    def ids(self) -> Sequence[_builtins.str]:
+        """
+        A list of Index IDs.
+        """
+        return pulumi.get(self, "ids")
+
+    @_builtins.property
+    @pulumi.getter
+    def indexs(self) -> Sequence['outputs.GetIndexsIndexResult']:
+        """
+        A list of Index Entries. Each element contains the following attributes:
+        """
+        return pulumi.get(self, "indexs")
+
+    @_builtins.property
+    @pulumi.getter(name="logstoreName")
+    def logstore_name(self) -> _builtins.str:
+        return pulumi.get(self, "logstore_name")
+
+    @_builtins.property
+    @pulumi.getter(name="outputFile")
+    def output_file(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "output_file")
+
+    @_builtins.property
+    @pulumi.getter(name="projectName")
+    def project_name(self) -> _builtins.str:
+        return pulumi.get(self, "project_name")
+
+
+class AwaitableGetIndexsResult(GetIndexsResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetIndexsResult(
+            id=self.id,
+            ids=self.ids,
+            indexs=self.indexs,
+            logstore_name=self.logstore_name,
+            output_file=self.output_file,
+            project_name=self.project_name)
+
+
+def get_indexs(ids: Optional[Sequence[_builtins.str]] = None,
+               logstore_name: Optional[_builtins.str] = None,
+               output_file: Optional[_builtins.str] = None,
+               project_name: Optional[_builtins.str] = None,
+               opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetIndexsResult:
+    """
+    This data source provides Sls Index available to the user.[What is Index](https://next.api.alibabacloud.com/document/Sls/2020-12-30/CreateIndex)
+
+    > **NOTE:** Available since v1.262.0.
+
+    ## Example Usage
+
+    ```python
+    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)
+    ```
+
+
+    :param Sequence[_builtins.str] ids: A list of Index IDs. The value is formulated as `<project_name>:<logstore_name>`.
+    :param _builtins.str logstore_name: Logstore name
+    :param _builtins.str output_file: File name where to save data source results (after running `pulumi preview`).
+    :param _builtins.str project_name: Project name
+    """
+    __args__ = dict()
+    __args__['ids'] = ids
+    __args__['logstoreName'] = logstore_name
+    __args__['outputFile'] = output_file
+    __args__['projectName'] = project_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('alicloud:sls/getIndexs:getIndexs', __args__, opts=opts, typ=GetIndexsResult).value
+
+    return AwaitableGetIndexsResult(
+        id=pulumi.get(__ret__, 'id'),
+        ids=pulumi.get(__ret__, 'ids'),
+        indexs=pulumi.get(__ret__, 'indexs'),
+        logstore_name=pulumi.get(__ret__, 'logstore_name'),
+        output_file=pulumi.get(__ret__, 'output_file'),
+        project_name=pulumi.get(__ret__, 'project_name'))
+def get_indexs_output(ids: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None,
+                      logstore_name: Optional[pulumi.Input[_builtins.str]] = None,
+                      output_file: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                      project_name: Optional[pulumi.Input[_builtins.str]] = None,
+                      opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetIndexsResult]:
+    """
+    This data source provides Sls Index available to the user.[What is Index](https://next.api.alibabacloud.com/document/Sls/2020-12-30/CreateIndex)
+
+    > **NOTE:** Available since v1.262.0.
+
+    ## Example Usage
+
+    ```python
+    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)
+    ```
+
+
+    :param Sequence[_builtins.str] ids: A list of Index IDs. The value is formulated as `<project_name>:<logstore_name>`.
+    :param _builtins.str logstore_name: Logstore name
+    :param _builtins.str output_file: File name where to save data source results (after running `pulumi preview`).
+    :param _builtins.str project_name: Project name
+    """
+    __args__ = dict()
+    __args__['ids'] = ids
+    __args__['logstoreName'] = logstore_name
+    __args__['outputFile'] = output_file
+    __args__['projectName'] = project_name
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('alicloud:sls/getIndexs:getIndexs', __args__, opts=opts, typ=GetIndexsResult)
+    return __ret__.apply(lambda __response__: GetIndexsResult(
+        id=pulumi.get(__response__, 'id'),
+        ids=pulumi.get(__response__, 'ids'),
+        indexs=pulumi.get(__response__, 'indexs'),
+        logstore_name=pulumi.get(__response__, 'logstore_name'),
+        output_file=pulumi.get(__response__, 'output_file'),
+        project_name=pulumi.get(__response__, 'project_name')))