pulumi-gcp 8.10.0a1731950704__py3-none-any.whl → 8.10.0a1732125494__py3-none-any.whl

pulumi_gcp/dataproc/outputs.py

@@ -83,6 +83,11 @@ __all__ = [
     'GdcApplicationEnvironmentSparkApplicationEnvironmentConfig',
     'GdcServiceInstanceGdceCluster',
     'GdcServiceInstanceSparkServiceInstanceConfig',
+    'GdcSparkApplicationPysparkApplicationConfig',
+    'GdcSparkApplicationSparkApplicationConfig',
+    'GdcSparkApplicationSparkRApplicationConfig',
+    'GdcSparkApplicationSparkSqlApplicationConfig',
+    'GdcSparkApplicationSparkSqlApplicationConfigQueryList',
     'JobHadoopConfig',
     'JobHadoopConfigLoggingConfig',
     'JobHiveConfig',
@@ -5298,6 +5303,386 @@ class GdcServiceInstanceSparkServiceInstanceConfig(dict):
         pass
 
 
+@pulumi.output_type
+class GdcSparkApplicationPysparkApplicationConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "mainPythonFileUri":
+            suggest = "main_python_file_uri"
+        elif key == "archiveUris":
+            suggest = "archive_uris"
+        elif key == "fileUris":
+            suggest = "file_uris"
+        elif key == "jarFileUris":
+            suggest = "jar_file_uris"
+        elif key == "pythonFileUris":
+            suggest = "python_file_uris"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in GdcSparkApplicationPysparkApplicationConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        GdcSparkApplicationPysparkApplicationConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        GdcSparkApplicationPysparkApplicationConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 main_python_file_uri: str,
+                 archive_uris: Optional[Sequence[str]] = None,
+                 args: Optional[Sequence[str]] = None,
+                 file_uris: Optional[Sequence[str]] = None,
+                 jar_file_uris: Optional[Sequence[str]] = None,
+                 python_file_uris: Optional[Sequence[str]] = None):
+        """
+        :param str main_python_file_uri: The HCFS URI of the main Python file to use as the driver. Must be a .py file.
+        :param Sequence[str] archive_uris: HCFS URIs of archives to be extracted into the working directory of each executor. Supported file types: .jar, .tar, .tar.gz, .tgz, and .zip.
+        :param Sequence[str] args: The arguments to pass to the driver.  Do not include arguments, such as `--conf`, that can be set as job properties, since a collision may occur that causes an incorrect job submission.
+        :param Sequence[str] file_uris: HCFS URIs of files to be placed in the working directory of each executor. Useful for naively parallel tasks.
+        :param Sequence[str] jar_file_uris: HCFS URIs of jar files to add to the CLASSPATHs of the Python driver and tasks.
+        :param Sequence[str] python_file_uris: HCFS file URIs of Python files to pass to the PySpark framework. Supported file types: .py, .egg, and .zip.
+        """
+        pulumi.set(__self__, "main_python_file_uri", main_python_file_uri)
+        if archive_uris is not None:
+            pulumi.set(__self__, "archive_uris", archive_uris)
+        if args is not None:
+            pulumi.set(__self__, "args", args)
+        if file_uris is not None:
+            pulumi.set(__self__, "file_uris", file_uris)
+        if jar_file_uris is not None:
+            pulumi.set(__self__, "jar_file_uris", jar_file_uris)
+        if python_file_uris is not None:
+            pulumi.set(__self__, "python_file_uris", python_file_uris)
+
+    @property
+    @pulumi.getter(name="mainPythonFileUri")
+    def main_python_file_uri(self) -> str:
+        """
+        The HCFS URI of the main Python file to use as the driver. Must be a .py file.
+        """
+        return pulumi.get(self, "main_python_file_uri")
+
+    @property
+    @pulumi.getter(name="archiveUris")
+    def archive_uris(self) -> Optional[Sequence[str]]:
+        """
+        HCFS URIs of archives to be extracted into the working directory of each executor. Supported file types: .jar, .tar, .tar.gz, .tgz, and .zip.
+        """
+        return pulumi.get(self, "archive_uris")
+
+    @property
+    @pulumi.getter
+    def args(self) -> Optional[Sequence[str]]:
+        """
+        The arguments to pass to the driver.  Do not include arguments, such as `--conf`, that can be set as job properties, since a collision may occur that causes an incorrect job submission.
+        """
+        return pulumi.get(self, "args")
+
+    @property
+    @pulumi.getter(name="fileUris")
+    def file_uris(self) -> Optional[Sequence[str]]:
+        """
+        HCFS URIs of files to be placed in the working directory of each executor. Useful for naively parallel tasks.
+        """
+        return pulumi.get(self, "file_uris")
+
+    @property
+    @pulumi.getter(name="jarFileUris")
+    def jar_file_uris(self) -> Optional[Sequence[str]]:
+        """
+        HCFS URIs of jar files to add to the CLASSPATHs of the Python driver and tasks.
+        """
+        return pulumi.get(self, "jar_file_uris")
+
+    @property
+    @pulumi.getter(name="pythonFileUris")
+    def python_file_uris(self) -> Optional[Sequence[str]]:
+        """
+        HCFS file URIs of Python files to pass to the PySpark framework. Supported file types: .py, .egg, and .zip.
+        """
+        return pulumi.get(self, "python_file_uris")
+
+
+@pulumi.output_type
+class GdcSparkApplicationSparkApplicationConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "archiveUris":
+            suggest = "archive_uris"
+        elif key == "fileUris":
+            suggest = "file_uris"
+        elif key == "jarFileUris":
+            suggest = "jar_file_uris"
+        elif key == "mainClass":
+            suggest = "main_class"
+        elif key == "mainJarFileUri":
+            suggest = "main_jar_file_uri"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in GdcSparkApplicationSparkApplicationConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        GdcSparkApplicationSparkApplicationConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        GdcSparkApplicationSparkApplicationConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 archive_uris: Optional[Sequence[str]] = None,
+                 args: Optional[Sequence[str]] = None,
+                 file_uris: Optional[Sequence[str]] = None,
+                 jar_file_uris: Optional[Sequence[str]] = None,
+                 main_class: Optional[str] = None,
+                 main_jar_file_uri: Optional[str] = None):
+        """
+        :param Sequence[str] archive_uris: HCFS URIs of archives to be extracted into the working directory of each executor. Supported file types: `.jar`, `.tar`, `.tar.gz`, `.tgz`, and `.zip`.
+        :param Sequence[str] args: The arguments to pass to the driver. Do not include arguments that can be set as application properties, such as `--conf`, since a collision can occur that causes an incorrect application submission.
+        :param Sequence[str] file_uris: HCFS URIs of files to be placed in the working directory of each executor.
+        :param Sequence[str] jar_file_uris: HCFS URIs of jar files to add to the classpath of the Spark driver and tasks.
+        :param str main_class: The name of the driver main class. The jar file that contains the class must be in the classpath or specified in `jar_file_uris`.
+        :param str main_jar_file_uri: The HCFS URI of the jar file that contains the main class.
+        """
+        if archive_uris is not None:
+            pulumi.set(__self__, "archive_uris", archive_uris)
+        if args is not None:
+            pulumi.set(__self__, "args", args)
+        if file_uris is not None:
+            pulumi.set(__self__, "file_uris", file_uris)
+        if jar_file_uris is not None:
+            pulumi.set(__self__, "jar_file_uris", jar_file_uris)
+        if main_class is not None:
+            pulumi.set(__self__, "main_class", main_class)
+        if main_jar_file_uri is not None:
+            pulumi.set(__self__, "main_jar_file_uri", main_jar_file_uri)
+
+    @property
+    @pulumi.getter(name="archiveUris")
+    def archive_uris(self) -> Optional[Sequence[str]]:
+        """
+        HCFS URIs of archives to be extracted into the working directory of each executor. Supported file types: `.jar`, `.tar`, `.tar.gz`, `.tgz`, and `.zip`.
+        """
+        return pulumi.get(self, "archive_uris")
+
+    @property
+    @pulumi.getter
+    def args(self) -> Optional[Sequence[str]]:
+        """
+        The arguments to pass to the driver. Do not include arguments that can be set as application properties, such as `--conf`, since a collision can occur that causes an incorrect application submission.
+        """
+        return pulumi.get(self, "args")
+
+    @property
+    @pulumi.getter(name="fileUris")
+    def file_uris(self) -> Optional[Sequence[str]]:
+        """
+        HCFS URIs of files to be placed in the working directory of each executor.
+        """
+        return pulumi.get(self, "file_uris")
+
+    @property
+    @pulumi.getter(name="jarFileUris")
+    def jar_file_uris(self) -> Optional[Sequence[str]]:
+        """
+        HCFS URIs of jar files to add to the classpath of the Spark driver and tasks.
+        """
+        return pulumi.get(self, "jar_file_uris")
+
+    @property
+    @pulumi.getter(name="mainClass")
+    def main_class(self) -> Optional[str]:
+        """
+        The name of the driver main class. The jar file that contains the class must be in the classpath or specified in `jar_file_uris`.
+        """
+        return pulumi.get(self, "main_class")
+
+    @property
+    @pulumi.getter(name="mainJarFileUri")
+    def main_jar_file_uri(self) -> Optional[str]:
+        """
+        The HCFS URI of the jar file that contains the main class.
+        """
+        return pulumi.get(self, "main_jar_file_uri")
+
+
+@pulumi.output_type
+class GdcSparkApplicationSparkRApplicationConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "mainRFileUri":
+            suggest = "main_r_file_uri"
+        elif key == "archiveUris":
+            suggest = "archive_uris"
+        elif key == "fileUris":
+            suggest = "file_uris"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in GdcSparkApplicationSparkRApplicationConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        GdcSparkApplicationSparkRApplicationConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        GdcSparkApplicationSparkRApplicationConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 main_r_file_uri: str,
+                 archive_uris: Optional[Sequence[str]] = None,
+                 args: Optional[Sequence[str]] = None,
+                 file_uris: Optional[Sequence[str]] = None):
+        """
+        :param str main_r_file_uri: The HCFS URI of the main R file to use as the driver. Must be a .R file.
+        :param Sequence[str] archive_uris: HCFS URIs of archives to be extracted into the working directory of each executor. Supported file types: .jar, .tar, .tar.gz, .tgz, and .zip.
+        :param Sequence[str] args: The arguments to pass to the driver.  Do not include arguments, such as `--conf`, that can be set as job properties, since a collision may occur that causes an incorrect job submission.
+        :param Sequence[str] file_uris: HCFS URIs of files to be placed in the working directory of each executor. Useful for naively parallel tasks.
+        """
+        pulumi.set(__self__, "main_r_file_uri", main_r_file_uri)
+        if archive_uris is not None:
+            pulumi.set(__self__, "archive_uris", archive_uris)
+        if args is not None:
+            pulumi.set(__self__, "args", args)
+        if file_uris is not None:
+            pulumi.set(__self__, "file_uris", file_uris)
+
+    @property
+    @pulumi.getter(name="mainRFileUri")
+    def main_r_file_uri(self) -> str:
+        """
+        The HCFS URI of the main R file to use as the driver. Must be a .R file.
+        """
+        return pulumi.get(self, "main_r_file_uri")
+
+    @property
+    @pulumi.getter(name="archiveUris")
+    def archive_uris(self) -> Optional[Sequence[str]]:
+        """
+        HCFS URIs of archives to be extracted into the working directory of each executor. Supported file types: .jar, .tar, .tar.gz, .tgz, and .zip.
+        """
+        return pulumi.get(self, "archive_uris")
+
+    @property
+    @pulumi.getter
+    def args(self) -> Optional[Sequence[str]]:
+        """
+        The arguments to pass to the driver.  Do not include arguments, such as `--conf`, that can be set as job properties, since a collision may occur that causes an incorrect job submission.
+        """
+        return pulumi.get(self, "args")
+
+    @property
+    @pulumi.getter(name="fileUris")
+    def file_uris(self) -> Optional[Sequence[str]]:
+        """
+        HCFS URIs of files to be placed in the working directory of each executor. Useful for naively parallel tasks.
+        """
+        return pulumi.get(self, "file_uris")
+
+
+@pulumi.output_type
+class GdcSparkApplicationSparkSqlApplicationConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "jarFileUris":
+            suggest = "jar_file_uris"
+        elif key == "queryFileUri":
+            suggest = "query_file_uri"
+        elif key == "queryList":
+            suggest = "query_list"
+        elif key == "scriptVariables":
+            suggest = "script_variables"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in GdcSparkApplicationSparkSqlApplicationConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        GdcSparkApplicationSparkSqlApplicationConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        GdcSparkApplicationSparkSqlApplicationConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 jar_file_uris: Optional[Sequence[str]] = None,
+                 query_file_uri: Optional[str] = None,
+                 query_list: Optional['outputs.GdcSparkApplicationSparkSqlApplicationConfigQueryList'] = None,
+                 script_variables: Optional[Mapping[str, str]] = None):
+        """
+        :param Sequence[str] jar_file_uris: HCFS URIs of jar files to be added to the Spark CLASSPATH.
+        :param str query_file_uri: The HCFS URI of the script that contains SQL queries.
+        :param 'GdcSparkApplicationSparkSqlApplicationConfigQueryListArgs' query_list: Represents a list of queries.
+               Structure is documented below.
+        :param Mapping[str, str] script_variables: Mapping of query variable names to values (equivalent to the Spark SQL command: SET `name="value";`).
+        """
+        if jar_file_uris is not None:
+            pulumi.set(__self__, "jar_file_uris", jar_file_uris)
+        if query_file_uri is not None:
+            pulumi.set(__self__, "query_file_uri", query_file_uri)
+        if query_list is not None:
+            pulumi.set(__self__, "query_list", query_list)
+        if script_variables is not None:
+            pulumi.set(__self__, "script_variables", script_variables)
+
+    @property
+    @pulumi.getter(name="jarFileUris")
+    def jar_file_uris(self) -> Optional[Sequence[str]]:
+        """
+        HCFS URIs of jar files to be added to the Spark CLASSPATH.
+        """
+        return pulumi.get(self, "jar_file_uris")
+
+    @property
+    @pulumi.getter(name="queryFileUri")
+    def query_file_uri(self) -> Optional[str]:
+        """
+        The HCFS URI of the script that contains SQL queries.
+        """
+        return pulumi.get(self, "query_file_uri")
+
+    @property
+    @pulumi.getter(name="queryList")
+    def query_list(self) -> Optional['outputs.GdcSparkApplicationSparkSqlApplicationConfigQueryList']:
+        """
+        Represents a list of queries.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "query_list")
+
+    @property
+    @pulumi.getter(name="scriptVariables")
+    def script_variables(self) -> Optional[Mapping[str, str]]:
+        """
+        Mapping of query variable names to values (equivalent to the Spark SQL command: SET `name="value";`).
+        """
+        return pulumi.get(self, "script_variables")
+
+
+@pulumi.output_type
+class GdcSparkApplicationSparkSqlApplicationConfigQueryList(dict):
+    def __init__(__self__, *,
+                 queries: Sequence[str]):
+        """
+        :param Sequence[str] queries: The queries to run.
+        """
+        pulumi.set(__self__, "queries", queries)
+
+    @property
+    @pulumi.getter
+    def queries(self) -> Sequence[str]:
+        """
+        The queries to run.
+        """
+        return pulumi.get(self, "queries")
+
+
 @pulumi.output_type
 class JobHadoopConfig(dict):
     @staticmethod

pulumi_gcp/filestore/_inputs.py

@@ -21,6 +21,12 @@ __all__ = [
     'InstanceFileSharesNfsExportOptionArgsDict',
     'InstanceNetworkArgs',
     'InstanceNetworkArgsDict',
+    'InstancePerformanceConfigArgs',
+    'InstancePerformanceConfigArgsDict',
+    'InstancePerformanceConfigFixedIopsArgs',
+    'InstancePerformanceConfigFixedIopsArgsDict',
+    'InstancePerformanceConfigIopsPerTbArgs',
+    'InstancePerformanceConfigIopsPerTbArgsDict',
 ]
 
 MYPY = False
@@ -418,3 +424,149 @@ class InstanceNetworkArgs:
         pulumi.set(self, "reserved_ip_range", value)
 
 
+if not MYPY:
+    class InstancePerformanceConfigArgsDict(TypedDict):
+        fixed_iops: NotRequired[pulumi.Input['InstancePerformanceConfigFixedIopsArgsDict']]
+        """
+        The instance will have a fixed provisioned IOPS value,
+        which will remain constant regardless of instance
+        capacity.
+        Structure is documented below.
+        """
+        iops_per_tb: NotRequired[pulumi.Input['InstancePerformanceConfigIopsPerTbArgsDict']]
+        """
+        The instance provisioned IOPS will change dynamically
+        based on the capacity of the instance.
+        Structure is documented below.
+        """
+elif False:
+    InstancePerformanceConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstancePerformanceConfigArgs:
+    def __init__(__self__, *,
+                 fixed_iops: Optional[pulumi.Input['InstancePerformanceConfigFixedIopsArgs']] = None,
+                 iops_per_tb: Optional[pulumi.Input['InstancePerformanceConfigIopsPerTbArgs']] = None):
+        """
+        :param pulumi.Input['InstancePerformanceConfigFixedIopsArgs'] fixed_iops: The instance will have a fixed provisioned IOPS value,
+               which will remain constant regardless of instance
+               capacity.
+               Structure is documented below.
+        :param pulumi.Input['InstancePerformanceConfigIopsPerTbArgs'] iops_per_tb: The instance provisioned IOPS will change dynamically
+               based on the capacity of the instance.
+               Structure is documented below.
+        """
+        if fixed_iops is not None:
+            pulumi.set(__self__, "fixed_iops", fixed_iops)
+        if iops_per_tb is not None:
+            pulumi.set(__self__, "iops_per_tb", iops_per_tb)
+
+    @property
+    @pulumi.getter(name="fixedIops")
+    def fixed_iops(self) -> Optional[pulumi.Input['InstancePerformanceConfigFixedIopsArgs']]:
+        """
+        The instance will have a fixed provisioned IOPS value,
+        which will remain constant regardless of instance
+        capacity.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "fixed_iops")
+
+    @fixed_iops.setter
+    def fixed_iops(self, value: Optional[pulumi.Input['InstancePerformanceConfigFixedIopsArgs']]):
+        pulumi.set(self, "fixed_iops", value)
+
+    @property
+    @pulumi.getter(name="iopsPerTb")
+    def iops_per_tb(self) -> Optional[pulumi.Input['InstancePerformanceConfigIopsPerTbArgs']]:
+        """
+        The instance provisioned IOPS will change dynamically
+        based on the capacity of the instance.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "iops_per_tb")
+
+    @iops_per_tb.setter
+    def iops_per_tb(self, value: Optional[pulumi.Input['InstancePerformanceConfigIopsPerTbArgs']]):
+        pulumi.set(self, "iops_per_tb", value)
+
+
+if not MYPY:
+    class InstancePerformanceConfigFixedIopsArgsDict(TypedDict):
+        max_iops: NotRequired[pulumi.Input[int]]
+        """
+        The number of IOPS to provision for the instance.
+        max_iops must be in multiple of 1000.
+        """
+elif False:
+    InstancePerformanceConfigFixedIopsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstancePerformanceConfigFixedIopsArgs:
+    def __init__(__self__, *,
+                 max_iops: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[int] max_iops: The number of IOPS to provision for the instance.
+               max_iops must be in multiple of 1000.
+        """
+        if max_iops is not None:
+            pulumi.set(__self__, "max_iops", max_iops)
+
+    @property
+    @pulumi.getter(name="maxIops")
+    def max_iops(self) -> Optional[pulumi.Input[int]]:
+        """
+        The number of IOPS to provision for the instance.
+        max_iops must be in multiple of 1000.
+        """
+        return pulumi.get(self, "max_iops")
+
+    @max_iops.setter
+    def max_iops(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_iops", value)
+
+
+if not MYPY:
+    class InstancePerformanceConfigIopsPerTbArgsDict(TypedDict):
+        max_iops_per_tb: NotRequired[pulumi.Input[int]]
+        """
+        The instance max IOPS will be calculated by multiplying
+        the capacity of the instance (TB) by max_iops_per_tb,
+        and rounding to the nearest 1000. The instance max IOPS
+        will be changed dynamically based on the instance
+        capacity.
+        """
+elif False:
+    InstancePerformanceConfigIopsPerTbArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstancePerformanceConfigIopsPerTbArgs:
+    def __init__(__self__, *,
+                 max_iops_per_tb: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[int] max_iops_per_tb: The instance max IOPS will be calculated by multiplying
+               the capacity of the instance (TB) by max_iops_per_tb,
+               and rounding to the nearest 1000. The instance max IOPS
+               will be changed dynamically based on the instance
+               capacity.
+        """
+        if max_iops_per_tb is not None:
+            pulumi.set(__self__, "max_iops_per_tb", max_iops_per_tb)
+
+    @property
+    @pulumi.getter(name="maxIopsPerTb")
+    def max_iops_per_tb(self) -> Optional[pulumi.Input[int]]:
+        """
+        The instance max IOPS will be calculated by multiplying
+        the capacity of the instance (TB) by max_iops_per_tb,
+        and rounding to the nearest 1000. The instance max IOPS
+        will be changed dynamically based on the instance
+        capacity.
+        """
+        return pulumi.get(self, "max_iops_per_tb")
+
+    @max_iops_per_tb.setter
+    def max_iops_per_tb(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_iops_per_tb", value)
+
+

pulumi_gcp/filestore/get_instance.py

@@ -27,7 +27,7 @@ class GetInstanceResult:
     """
     A collection of values returned by getInstance.
     """
-    def __init__(__self__, create_time=None, deletion_protection_enabled=None, deletion_protection_reason=None, description=None, effective_labels=None, etag=None, file_shares=None, id=None, kms_key_name=None, labels=None, location=None, name=None, networks=None, project=None, protocol=None, pulumi_labels=None, tier=None, zone=None):
+    def __init__(__self__, create_time=None, deletion_protection_enabled=None, deletion_protection_reason=None, description=None, effective_labels=None, etag=None, file_shares=None, id=None, kms_key_name=None, labels=None, location=None, name=None, networks=None, performance_configs=None, project=None, protocol=None, pulumi_labels=None, tier=None, zone=None):
         if create_time and not isinstance(create_time, str):
             raise TypeError("Expected argument 'create_time' to be a str")
         pulumi.set(__self__, "create_time", create_time)
@@ -67,6 +67,9 @@ class GetInstanceResult:
         if networks and not isinstance(networks, list):
             raise TypeError("Expected argument 'networks' to be a list")
         pulumi.set(__self__, "networks", networks)
+        if performance_configs and not isinstance(performance_configs, list):
+            raise TypeError("Expected argument 'performance_configs' to be a list")
+        pulumi.set(__self__, "performance_configs", performance_configs)
         if project and not isinstance(project, str):
             raise TypeError("Expected argument 'project' to be a str")
         pulumi.set(__self__, "project", project)
@@ -151,6 +154,11 @@ class GetInstanceResult:
     def networks(self) -> Sequence['outputs.GetInstanceNetworkResult']:
         return pulumi.get(self, "networks")
 
+    @property
+    @pulumi.getter(name="performanceConfigs")
+    def performance_configs(self) -> Sequence['outputs.GetInstancePerformanceConfigResult']:
+        return pulumi.get(self, "performance_configs")
+
     @property
     @pulumi.getter
     def project(self) -> Optional[str]:
@@ -196,6 +204,7 @@ class AwaitableGetInstanceResult(GetInstanceResult):
             location=self.location,
             name=self.name,
             networks=self.networks,
+            performance_configs=self.performance_configs,
             project=self.project,
             protocol=self.protocol,
             pulumi_labels=self.pulumi_labels,
@@ -253,6 +262,7 @@ def get_instance(location: Optional[str] = None,
         location=pulumi.get(__ret__, 'location'),
         name=pulumi.get(__ret__, 'name'),
         networks=pulumi.get(__ret__, 'networks'),
+        performance_configs=pulumi.get(__ret__, 'performance_configs'),
         project=pulumi.get(__ret__, 'project'),
         protocol=pulumi.get(__ret__, 'protocol'),
         pulumi_labels=pulumi.get(__ret__, 'pulumi_labels'),
@@ -307,6 +317,7 @@ def get_instance_output(location: Optional[pulumi.Input[Optional[str]]] = None,
         location=pulumi.get(__response__, 'location'),
         name=pulumi.get(__response__, 'name'),
         networks=pulumi.get(__response__, 'networks'),
+        performance_configs=pulumi.get(__response__, 'performance_configs'),
         project=pulumi.get(__response__, 'project'),
         protocol=pulumi.get(__response__, 'protocol'),
         pulumi_labels=pulumi.get(__response__, 'pulumi_labels'),