pulumi-alicloud 3.87.0a1760678219__py3-none-any.whl → 3.88.0__py3-none-any.whl

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')))

pulumi_alicloud/sls/outputs.py

@@ -63,6 +63,8 @@ __all__ = [
     'GetEtlsEtlResult',
     'GetEtlsEtlConfigurationResult',
     'GetEtlsEtlConfigurationSinkResult',
+    'GetIndexsIndexResult',
+    'GetIndexsIndexLineResult',
     'GetLogtailConfigsConfigResult',
     'GetMachineGroupsGroupResult',
 ]
@@ -3807,6 +3809,152 @@ class GetEtlsEtlConfigurationSinkResult(dict):
         return pulumi.get(self, "role_arn")
 
 
+@pulumi.output_type
+class GetIndexsIndexResult(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str,
+                 keys: _builtins.str,
+                 line: 'outputs.GetIndexsIndexLineResult',
+                 log_reduce_black_lists: Sequence[_builtins.str],
+                 log_reduce_white_lists: Sequence[_builtins.str],
+                 max_text_len: _builtins.int,
+                 ttl: _builtins.int):
+        """
+        :param _builtins.str id: The ID of the resource supplied above.
+        :param _builtins.str keys: Field index
+        :param 'GetIndexsIndexLineArgs' line: Full-text index
+        :param Sequence[_builtins.str] log_reduce_black_lists: The blacklist of the cluster fields of log clustering is filtered only when log clustering is enabled.
+        :param Sequence[_builtins.str] log_reduce_white_lists: The whitelist of the cluster fields for log clustering. This filter is valid only when log clustering is enabled.
+        :param _builtins.int max_text_len: Maximum length of statistical field
+        :param _builtins.int ttl: Log index storage time
+        """
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "keys", keys)
+        pulumi.set(__self__, "line", line)
+        pulumi.set(__self__, "log_reduce_black_lists", log_reduce_black_lists)
+        pulumi.set(__self__, "log_reduce_white_lists", log_reduce_white_lists)
+        pulumi.set(__self__, "max_text_len", max_text_len)
+        pulumi.set(__self__, "ttl", ttl)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the resource supplied above.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter
+    def keys(self) -> _builtins.str:
+        """
+        Field index
+        """
+        return pulumi.get(self, "keys")
+
+    @_builtins.property
+    @pulumi.getter
+    def line(self) -> 'outputs.GetIndexsIndexLineResult':
+        """
+        Full-text index
+        """
+        return pulumi.get(self, "line")
+
+    @_builtins.property
+    @pulumi.getter(name="logReduceBlackLists")
+    def log_reduce_black_lists(self) -> Sequence[_builtins.str]:
+        """
+        The blacklist of the cluster fields of log clustering is filtered only when log clustering is enabled.
+        """
+        return pulumi.get(self, "log_reduce_black_lists")
+
+    @_builtins.property
+    @pulumi.getter(name="logReduceWhiteLists")
+    def log_reduce_white_lists(self) -> Sequence[_builtins.str]:
+        """
+        The whitelist of the cluster fields for log clustering. This filter is valid only when log clustering is enabled.
+        """
+        return pulumi.get(self, "log_reduce_white_lists")
+
+    @_builtins.property
+    @pulumi.getter(name="maxTextLen")
+    def max_text_len(self) -> _builtins.int:
+        """
+        Maximum length of statistical field
+        """
+        return pulumi.get(self, "max_text_len")
+
+    @_builtins.property
+    @pulumi.getter
+    def ttl(self) -> _builtins.int:
+        """
+        Log index storage time
+        """
+        return pulumi.get(self, "ttl")
+
+
+@pulumi.output_type
+class GetIndexsIndexLineResult(dict):
+    def __init__(__self__, *,
+                 case_sensitive: _builtins.bool,
+                 chn: _builtins.bool,
+                 exclude_keys: Sequence[_builtins.str],
+                 include_keys: Sequence[_builtins.str],
+                 tokens: Sequence[_builtins.str]):
+        """
+        :param _builtins.bool case_sensitive: Is case sensitive.
+        :param _builtins.bool chn: Does it include Chinese.
+        :param Sequence[_builtins.str] exclude_keys: List of excluded fields.
+        :param Sequence[_builtins.str] include_keys: Include field list.
+        :param Sequence[_builtins.str] tokens: Delimiter.
+        """
+        pulumi.set(__self__, "case_sensitive", case_sensitive)
+        pulumi.set(__self__, "chn", chn)
+        pulumi.set(__self__, "exclude_keys", exclude_keys)
+        pulumi.set(__self__, "include_keys", include_keys)
+        pulumi.set(__self__, "tokens", tokens)
+
+    @_builtins.property
+    @pulumi.getter(name="caseSensitive")
+    def case_sensitive(self) -> _builtins.bool:
+        """
+        Is case sensitive.
+        """
+        return pulumi.get(self, "case_sensitive")
+
+    @_builtins.property
+    @pulumi.getter
+    def chn(self) -> _builtins.bool:
+        """
+        Does it include Chinese.
+        """
+        return pulumi.get(self, "chn")
+
+    @_builtins.property
+    @pulumi.getter(name="excludeKeys")
+    def exclude_keys(self) -> Sequence[_builtins.str]:
+        """
+        List of excluded fields.
+        """
+        return pulumi.get(self, "exclude_keys")
+
+    @_builtins.property
+    @pulumi.getter(name="includeKeys")
+    def include_keys(self) -> Sequence[_builtins.str]:
+        """
+        Include field list.
+        """
+        return pulumi.get(self, "include_keys")
+
+    @_builtins.property
+    @pulumi.getter
+    def tokens(self) -> Sequence[_builtins.str]:
+        """
+        Delimiter.
+        """
+        return pulumi.get(self, "tokens")
+
+
 @pulumi.output_type
 class GetLogtailConfigsConfigResult(dict):
     def __init__(__self__, *,

pulumi_alicloud/star_rocks_instance.py

@@ -786,8 +786,13 @@ class _StarRocksInstanceState:
         pulumi.set(self, "vswitches", value)
 
 
+warnings.warn("""alicloud.index/starrocksinstance.StarRocksInstance has been deprecated in favor of alicloud.starrocks/instance.Instance""", DeprecationWarning)
+
+
 @pulumi.type_token("alicloud:index/starRocksInstance:StarRocksInstance")
 class StarRocksInstance(pulumi.CustomResource):
+    warnings.warn("""alicloud.index/starrocksinstance.StarRocksInstance has been deprecated in favor of alicloud.starrocks/instance.Instance""", DeprecationWarning)
+
     @overload
     def __init__(__self__,
                  resource_name: str,
@@ -842,7 +847,7 @@ class StarRocksInstance(pulumi.CustomResource):
             cidr_block="172.16.1.0/24",
             vswitch_name="sr-example",
             zone_id="cn-hangzhou-i")
-        default_star_rocks_instance = alicloud.StarRocksInstance("default",
+        default_instance = alicloud.starrocks.Instance("default",
             instance_name="create-instance-1",
             auto_renew=False,
             frontend_node_groups=[{
@@ -970,7 +975,7 @@ class StarRocksInstance(pulumi.CustomResource):
             cidr_block="172.16.1.0/24",
             vswitch_name="sr-example",
             zone_id="cn-hangzhou-i")
-        default_star_rocks_instance = alicloud.StarRocksInstance("default",
+        default_instance = alicloud.starrocks.Instance("default",
             instance_name="create-instance-1",
             auto_renew=False,
             frontend_node_groups=[{
@@ -1067,6 +1072,7 @@ class StarRocksInstance(pulumi.CustomResource):
                  vpc_id: Optional[pulumi.Input[_builtins.str]] = None,
                  vswitches: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StarRocksInstanceVswitchArgs', 'StarRocksInstanceVswitchArgsDict']]]]] = None,
                  __props__=None):
+        pulumi.log.warn("""StarRocksInstance is deprecated: alicloud.index/starrocksinstance.StarRocksInstance has been deprecated in favor of alicloud.starrocks/instance.Instance""")
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
         if not isinstance(opts, pulumi.ResourceOptions):
             raise TypeError('Expected resource options to be a ResourceOptions instance')

pulumi_alicloud/starrocks/__init__.py

@@ -0,0 +1,12 @@
+# 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
+from .. import _utilities
+import typing
+# Export this package's modules as members:
+from .instance import *
+from .node_group import *
+from ._inputs import *
+from . import outputs