pulumi-gcp 8.23.0a1742538920__py3-none-any.whl → 8.24.0__py3-none-any.whl

pulumi_gcp/__init__.py

@@ -172,6 +172,8 @@ if typing.TYPE_CHECKING:
     logging = __logging
     import pulumi_gcp.looker as __looker
     looker = __looker
+    import pulumi_gcp.lustre as __lustre
+    lustre = __lustre
     import pulumi_gcp.managedkafka as __managedkafka
     managedkafka = __managedkafka
     import pulumi_gcp.memcache as __memcache
@@ -350,6 +352,7 @@ else:
     kms = _utilities.lazy_import('pulumi_gcp.kms')
     logging = _utilities.lazy_import('pulumi_gcp.logging')
     looker = _utilities.lazy_import('pulumi_gcp.looker')
+    lustre = _utilities.lazy_import('pulumi_gcp.lustre')
     managedkafka = _utilities.lazy_import('pulumi_gcp.managedkafka')
     memcache = _utilities.lazy_import('pulumi_gcp.memcache')
     memorystore = _utilities.lazy_import('pulumi_gcp.memorystore')
@@ -4970,6 +4973,14 @@ _utilities.register(
    "gcp:eventarc/messageBus:MessageBus": "MessageBus"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "eventarc/pipeline",
+  "fqn": "pulumi_gcp.eventarc",
+  "classes": {
+   "gcp:eventarc/pipeline:Pipeline": "Pipeline"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "eventarc/trigger",
@@ -5066,6 +5077,14 @@ _utilities.register(
    "gcp:firebase/appCheckServiceConfig:AppCheckServiceConfig": "AppCheckServiceConfig"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "firebase/appHostingBackend",
+  "fqn": "pulumi_gcp.firebase",
+  "classes": {
+   "gcp:firebase/appHostingBackend:AppHostingBackend": "AppHostingBackend"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "firebase/appleApp",
@@ -6570,6 +6589,14 @@ _utilities.register(
    "gcp:looker/instance:Instance": "Instance"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "lustre/instance",
+  "fqn": "pulumi_gcp.lustre",
+  "classes": {
+   "gcp:lustre/instance:Instance": "Instance"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "managedkafka/cluster",
@@ -6578,6 +6605,22 @@ _utilities.register(
    "gcp:managedkafka/cluster:Cluster": "Cluster"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "managedkafka/connectCluster",
+  "fqn": "pulumi_gcp.managedkafka",
+  "classes": {
+   "gcp:managedkafka/connectCluster:ConnectCluster": "ConnectCluster"
+  }
+ },
+ {
+  "pkg": "gcp",
+  "mod": "managedkafka/connector",
+  "fqn": "pulumi_gcp.managedkafka",
+  "classes": {
+   "gcp:managedkafka/connector:Connector": "Connector"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "managedkafka/topic",
@@ -7394,6 +7437,14 @@ _utilities.register(
    "gcp:osconfig/patchDeployment:PatchDeployment": "PatchDeployment"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "osconfig/v2PolicyOrchestrator",
+  "fqn": "pulumi_gcp.osconfig",
+  "classes": {
+   "gcp:osconfig/v2PolicyOrchestrator:V2PolicyOrchestrator": "V2PolicyOrchestrator"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "oslogin/sshPublicKey",
@@ -8594,6 +8645,14 @@ _utilities.register(
    "gcp:storage/bucketObject:BucketObject": "BucketObject"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "storage/controlProjectIntelligenceConfig",
+  "fqn": "pulumi_gcp.storage",
+  "classes": {
+   "gcp:storage/controlProjectIntelligenceConfig:ControlProjectIntelligenceConfig": "ControlProjectIntelligenceConfig"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "storage/defaultObjectACL",

pulumi_gcp/alloydb/_inputs.py

@@ -1448,18 +1448,30 @@ if not MYPY:
         """
         Create an instance that allows connections from Private Service Connect endpoints to the instance.
         """
+        service_owned_project_number: NotRequired[pulumi.Input[int]]
+        """
+        (Output)
+        The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+        In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
+        """
 elif False:
     ClusterPscConfigArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class ClusterPscConfigArgs:
     def __init__(__self__, *,
-                 psc_enabled: Optional[pulumi.Input[bool]] = None):
+                 psc_enabled: Optional[pulumi.Input[bool]] = None,
+                 service_owned_project_number: Optional[pulumi.Input[int]] = None):
         """
         :param pulumi.Input[bool] psc_enabled: Create an instance that allows connections from Private Service Connect endpoints to the instance.
+        :param pulumi.Input[int] service_owned_project_number: (Output)
+               The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+               In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
         """
         if psc_enabled is not None:
             pulumi.set(__self__, "psc_enabled", psc_enabled)
+        if service_owned_project_number is not None:
+            pulumi.set(__self__, "service_owned_project_number", service_owned_project_number)
 
     @property
     @pulumi.getter(name="pscEnabled")
@@ -1473,6 +1485,20 @@ class ClusterPscConfigArgs:
     def psc_enabled(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "psc_enabled", value)
 
+    @property
+    @pulumi.getter(name="serviceOwnedProjectNumber")
+    def service_owned_project_number(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Output)
+        The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+        In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
+        """
+        return pulumi.get(self, "service_owned_project_number")
+
+    @service_owned_project_number.setter
+    def service_owned_project_number(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "service_owned_project_number", value)
+
 
 if not MYPY:
     class ClusterRestoreBackupSourceArgsDict(TypedDict):

pulumi_gcp/alloydb/outputs.py

@@ -1243,6 +1243,8 @@ class ClusterPscConfig(dict):
         suggest = None
         if key == "pscEnabled":
             suggest = "psc_enabled"
+        elif key == "serviceOwnedProjectNumber":
+            suggest = "service_owned_project_number"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterPscConfig. Access the value via the '{suggest}' property getter instead.")
@@ -1256,12 +1258,18 @@ class ClusterPscConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 psc_enabled: Optional[bool] = None):
+                 psc_enabled: Optional[bool] = None,
+                 service_owned_project_number: Optional[int] = None):
         """
         :param bool psc_enabled: Create an instance that allows connections from Private Service Connect endpoints to the instance.
+        :param int service_owned_project_number: (Output)
+               The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+               In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
         """
         if psc_enabled is not None:
             pulumi.set(__self__, "psc_enabled", psc_enabled)
+        if service_owned_project_number is not None:
+            pulumi.set(__self__, "service_owned_project_number", service_owned_project_number)
 
     @property
     @pulumi.getter(name="pscEnabled")
@@ -1271,6 +1279,16 @@ class ClusterPscConfig(dict):
         """
         return pulumi.get(self, "psc_enabled")
 
+    @property
+    @pulumi.getter(name="serviceOwnedProjectNumber")
+    def service_owned_project_number(self) -> Optional[int]:
+        """
+        (Output)
+        The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+        In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
+        """
+        return pulumi.get(self, "service_owned_project_number")
+
 
 @pulumi.output_type
 class ClusterRestoreBackupSource(dict):
@@ -2735,11 +2753,15 @@ class GetClusterNetworkConfigResult(dict):
 @pulumi.output_type
 class GetClusterPscConfigResult(dict):
     def __init__(__self__, *,
-                 psc_enabled: bool):
+                 psc_enabled: bool,
+                 service_owned_project_number: int):
         """
         :param bool psc_enabled: Create an instance that allows connections from Private Service Connect endpoints to the instance.
+        :param int service_owned_project_number: The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+               In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
         """
         pulumi.set(__self__, "psc_enabled", psc_enabled)
+        pulumi.set(__self__, "service_owned_project_number", service_owned_project_number)
 
     @property
     @pulumi.getter(name="pscEnabled")
@@ -2749,6 +2771,15 @@ class GetClusterPscConfigResult(dict):
         """
         return pulumi.get(self, "psc_enabled")
 
+    @property
+    @pulumi.getter(name="serviceOwnedProjectNumber")
+    def service_owned_project_number(self) -> int:
+        """
+        The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+        In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
+        """
+        return pulumi.get(self, "service_owned_project_number")
+
 
 @pulumi.output_type
 class GetClusterRestoreBackupSourceResult(dict):

pulumi_gcp/applicationintegration/client.py

@@ -251,15 +251,12 @@ class Client(pulumi.CustomResource):
         import pulumi_gcp as gcp
         import pulumi_std as std
 
-        test_project = gcp.organizations.get_project()
-        keyring = gcp.kms.KeyRing("keyring",
-            name="my-keyring",
+        default = gcp.organizations.get_project()
+        keyring = gcp.kms.get_kms_key_ring(name="my-keyring",
             location="us-east1")
-        cryptokey = gcp.kms.CryptoKey("cryptokey",
-            name="crypto-key-example",
-            key_ring=keyring.id,
-            rotation_period="7776000s")
-        test_key = gcp.kms.CryptoKeyVersion("test_key", crypto_key=cryptokey.id)
+        cryptokey = gcp.kms.get_kms_crypto_key(name="my-crypto-key",
+            key_ring=keyring.id)
+        test_key = gcp.kms.get_kms_crypto_key_version(crypto_key=cryptokey.id)
         service_account = gcp.serviceaccount.Account("service_account",
             account_id="service-acc",
             display_name="Service Account")
@@ -269,10 +266,10 @@ class Client(pulumi.CustomResource):
             run_as_service_account=service_account.email,
             cloud_kms_config={
                 "kms_location": "us-east1",
-                "kms_ring": std.basename_output(input=keyring.id).apply(lambda invoke: invoke.result),
-                "key": std.basename_output(input=cryptokey.id).apply(lambda invoke: invoke.result),
-                "key_version": std.basename_output(input=test_key.id).apply(lambda invoke: invoke.result),
-                "kms_project_id": test_project.project_id,
+                "kms_ring": std.basename(input=keyring.id).result,
+                "key": std.basename(input=cryptokey.id).result,
+                "key_version": std.basename(input=test_key.id).result,
+                "kms_project_id": default.project_id,
             })
         ```
 
@@ -346,15 +343,12 @@ class Client(pulumi.CustomResource):
         import pulumi_gcp as gcp
         import pulumi_std as std
 
-        test_project = gcp.organizations.get_project()
-        keyring = gcp.kms.KeyRing("keyring",
-            name="my-keyring",
+        default = gcp.organizations.get_project()
+        keyring = gcp.kms.get_kms_key_ring(name="my-keyring",
             location="us-east1")
-        cryptokey = gcp.kms.CryptoKey("cryptokey",
-            name="crypto-key-example",
-            key_ring=keyring.id,
-            rotation_period="7776000s")
-        test_key = gcp.kms.CryptoKeyVersion("test_key", crypto_key=cryptokey.id)
+        cryptokey = gcp.kms.get_kms_crypto_key(name="my-crypto-key",
+            key_ring=keyring.id)
+        test_key = gcp.kms.get_kms_crypto_key_version(crypto_key=cryptokey.id)
         service_account = gcp.serviceaccount.Account("service_account",
             account_id="service-acc",
             display_name="Service Account")
@@ -364,10 +358,10 @@ class Client(pulumi.CustomResource):
             run_as_service_account=service_account.email,
             cloud_kms_config={
                 "kms_location": "us-east1",
-                "kms_ring": std.basename_output(input=keyring.id).apply(lambda invoke: invoke.result),
-                "key": std.basename_output(input=cryptokey.id).apply(lambda invoke: invoke.result),
-                "key_version": std.basename_output(input=test_key.id).apply(lambda invoke: invoke.result),
-                "kms_project_id": test_project.project_id,
+                "kms_ring": std.basename(input=keyring.id).result,
+                "key": std.basename(input=cryptokey.id).result,
+                "key_version": std.basename(input=test_key.id).result,
+                "kms_project_id": default.project_id,
             })
         ```
 

pulumi_gcp/bigquery/_inputs.py

@@ -129,6 +129,10 @@ __all__ = [
     'JobStatusErrorResultArgsDict',
     'ReservationAutoscaleArgs',
     'ReservationAutoscaleArgsDict',
+    'ReservationReplicationStatusArgs',
+    'ReservationReplicationStatusArgsDict',
+    'ReservationReplicationStatusErrorArgs',
+    'ReservationReplicationStatusErrorArgsDict',
     'RoutineArgumentArgs',
     'RoutineArgumentArgsDict',
     'RoutineRemoteFunctionOptionsArgs',
@@ -4099,6 +4103,10 @@ if not MYPY:
         Requires destinationTable to be set. For standard SQL queries, this flag is ignored and large results are always allowed.
         However, you must still set destinationTable when result size exceeds the allowed maximum response size.
         """
+        continuous: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to run the query as continuous or a regular query.
+        """
         create_disposition: NotRequired[pulumi.Input[str]]
         """
         Specifies whether the job is allowed to create new tables. The following values are supported:
@@ -4200,6 +4208,7 @@ class JobQueryArgs:
     def __init__(__self__, *,
                  query: pulumi.Input[str],
                  allow_large_results: Optional[pulumi.Input[bool]] = None,
+                 continuous: Optional[pulumi.Input[bool]] = None,
                  create_disposition: Optional[pulumi.Input[str]] = None,
                  default_dataset: Optional[pulumi.Input['JobQueryDefaultDatasetArgs']] = None,
                  destination_encryption_configuration: Optional[pulumi.Input['JobQueryDestinationEncryptionConfigurationArgs']] = None,
@@ -4222,6 +4231,7 @@ class JobQueryArgs:
         :param pulumi.Input[bool] allow_large_results: If true and query uses legacy SQL dialect, allows the query to produce arbitrarily large result tables at a slight cost in performance.
                Requires destinationTable to be set. For standard SQL queries, this flag is ignored and large results are always allowed.
                However, you must still set destinationTable when result size exceeds the allowed maximum response size.
+        :param pulumi.Input[bool] continuous: Whether to run the query as continuous or a regular query.
         :param pulumi.Input[str] create_disposition: Specifies whether the job is allowed to create new tables. The following values are supported:
                CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table.
                CREATE_NEVER: The table must already exist. If it does not, a 'notFound' error is returned in the job result.
@@ -4274,6 +4284,8 @@ class JobQueryArgs:
         pulumi.set(__self__, "query", query)
         if allow_large_results is not None:
             pulumi.set(__self__, "allow_large_results", allow_large_results)
+        if continuous is not None:
+            pulumi.set(__self__, "continuous", continuous)
         if create_disposition is not None:
             pulumi.set(__self__, "create_disposition", create_disposition)
         if default_dataset is not None:
@@ -4333,6 +4345,18 @@ class JobQueryArgs:
     def allow_large_results(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "allow_large_results", value)
 
+    @property
+    @pulumi.getter
+    def continuous(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether to run the query as continuous or a regular query.
+        """
+        return pulumi.get(self, "continuous")
+
+    @continuous.setter
+    def continuous(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "continuous", value)
+
     @property
     @pulumi.getter(name="createDisposition")
     def create_disposition(self) -> Optional[pulumi.Input[str]]:
@@ -5157,6 +5181,160 @@ class ReservationAutoscaleArgs:
         pulumi.set(self, "max_slots", value)
 
 
+if not MYPY:
+    class ReservationReplicationStatusArgsDict(TypedDict):
+        errors: NotRequired[pulumi.Input[Sequence[pulumi.Input['ReservationReplicationStatusErrorArgsDict']]]]
+        """
+        (Output)
+        The last error encountered while trying to replicate changes from the primary to the
+        secondary. This field is only available if the replication has not succeeded since.
+        Structure is documented below.
+        """
+        last_error_time: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        The time at which the last error was encountered while trying to replicate changes from
+        the primary to the secondary. This field is only available if the replication has not
+        succeeded since.
+        """
+        last_replication_time: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        A timestamp corresponding to the last change on the primary that was successfully
+        replicated to the secondary.
+        """
+elif False:
+    ReservationReplicationStatusArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ReservationReplicationStatusArgs:
+    def __init__(__self__, *,
+                 errors: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationReplicationStatusErrorArgs']]]] = None,
+                 last_error_time: Optional[pulumi.Input[str]] = None,
+                 last_replication_time: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['ReservationReplicationStatusErrorArgs']]] errors: (Output)
+               The last error encountered while trying to replicate changes from the primary to the
+               secondary. This field is only available if the replication has not succeeded since.
+               Structure is documented below.
+        :param pulumi.Input[str] last_error_time: (Output)
+               The time at which the last error was encountered while trying to replicate changes from
+               the primary to the secondary. This field is only available if the replication has not
+               succeeded since.
+        :param pulumi.Input[str] last_replication_time: (Output)
+               A timestamp corresponding to the last change on the primary that was successfully
+               replicated to the secondary.
+        """
+        if errors is not None:
+            pulumi.set(__self__, "errors", errors)
+        if last_error_time is not None:
+            pulumi.set(__self__, "last_error_time", last_error_time)
+        if last_replication_time is not None:
+            pulumi.set(__self__, "last_replication_time", last_replication_time)
+
+    @property
+    @pulumi.getter
+    def errors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ReservationReplicationStatusErrorArgs']]]]:
+        """
+        (Output)
+        The last error encountered while trying to replicate changes from the primary to the
+        secondary. This field is only available if the replication has not succeeded since.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "errors")
+
+    @errors.setter
+    def errors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationReplicationStatusErrorArgs']]]]):
+        pulumi.set(self, "errors", value)
+
+    @property
+    @pulumi.getter(name="lastErrorTime")
+    def last_error_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        The time at which the last error was encountered while trying to replicate changes from
+        the primary to the secondary. This field is only available if the replication has not
+        succeeded since.
+        """
+        return pulumi.get(self, "last_error_time")
+
+    @last_error_time.setter
+    def last_error_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "last_error_time", value)
+
+    @property
+    @pulumi.getter(name="lastReplicationTime")
+    def last_replication_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        A timestamp corresponding to the last change on the primary that was successfully
+        replicated to the secondary.
+        """
+        return pulumi.get(self, "last_replication_time")
+
+    @last_replication_time.setter
+    def last_replication_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "last_replication_time", value)
+
+
+if not MYPY:
+    class ReservationReplicationStatusErrorArgsDict(TypedDict):
+        code: NotRequired[pulumi.Input[int]]
+        """
+        (Output)
+        The status code, which should be an enum value of [google.rpc.Code](https://cloud.google.com/bigquery/docs/reference/reservations/rpc/google.rpc#google.rpc.Code).
+        """
+        message: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        A developer-facing error message, which should be in English.
+        """
+elif False:
+    ReservationReplicationStatusErrorArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ReservationReplicationStatusErrorArgs:
+    def __init__(__self__, *,
+                 code: Optional[pulumi.Input[int]] = None,
+                 message: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[int] code: (Output)
+               The status code, which should be an enum value of [google.rpc.Code](https://cloud.google.com/bigquery/docs/reference/reservations/rpc/google.rpc#google.rpc.Code).
+        :param pulumi.Input[str] message: (Output)
+               A developer-facing error message, which should be in English.
+        """
+        if code is not None:
+            pulumi.set(__self__, "code", code)
+        if message is not None:
+            pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def code(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Output)
+        The status code, which should be an enum value of [google.rpc.Code](https://cloud.google.com/bigquery/docs/reference/reservations/rpc/google.rpc#google.rpc.Code).
+        """
+        return pulumi.get(self, "code")
+
+    @code.setter
+    def code(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "code", value)
+
+    @property
+    @pulumi.getter
+    def message(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        A developer-facing error message, which should be in English.
+        """
+        return pulumi.get(self, "message")
+
+    @message.setter
+    def message(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "message", value)
+
+
 if not MYPY:
     class RoutineArgumentArgsDict(TypedDict):
         argument_kind: NotRequired[pulumi.Input[str]]