pulumi-gcp 7.10.0a1708496697__py3-none-any.whl → 7.11.0a1708599049__py3-none-any.whl

pulumi_gcp/compute/outputs.py

@@ -6028,18 +6028,18 @@ class InstanceBootDiskInitializeParams(dict):
                field is only applicable for persistent disks.
         :param int provisioned_iops: Indicates how many IOPS to provision for the disk.
                This sets the number of I/O operations per second that the disk can handle.
-               Values must be between 10,000 and 120,000. For more details,see the
-               [Extreme persistent disk documentation](https://cloud.google.com/compute/docs/disks/extreme-persistent-disk).
+               For more details,see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
                Note: Updating currently is only supported for hyperdisk skus via disk update
                api/gcloud without the need to delete and recreate the disk, hyperdisk allows
                for an update of IOPS every 4 hours. To update your hyperdisk more frequently,
                you'll need to manually delete and recreate it.
         :param int provisioned_throughput: Indicates how much throughput to provision for the disk.
                This sets the number of throughput mb per second that the disk can handle.
-               Values must be between 1 and 7,124. Note: Updating currently is only supported
-               for hyperdisk skus via disk update api/gcloud without the need to delete and
-               recreate the disk, hyperdisk allows for an update of throughput every 4 hours.
-               To update your hyperdisk more frequently, you'll need to manually delete and recreate it.
+               For more details,see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
+               Note: Updating currently is only supported for hyperdisk skus via disk update
+               api/gcloud without the need to delete and recreate the disk, hyperdisk allows
+               for an update of throughput every 4 hours. To update your hyperdisk more
+               frequently, you'll need to manually delete and recreate it.
         :param Mapping[str, Any] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param int size: The size of the image in gigabytes. If not specified, it
                will inherit the size of its base image.
@@ -6102,8 +6102,7 @@ class InstanceBootDiskInitializeParams(dict):
         """
         Indicates how many IOPS to provision for the disk.
         This sets the number of I/O operations per second that the disk can handle.
-        Values must be between 10,000 and 120,000. For more details,see the
-        [Extreme persistent disk documentation](https://cloud.google.com/compute/docs/disks/extreme-persistent-disk).
+        For more details,see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
         Note: Updating currently is only supported for hyperdisk skus via disk update
         api/gcloud without the need to delete and recreate the disk, hyperdisk allows
         for an update of IOPS every 4 hours. To update your hyperdisk more frequently,
@@ -6117,10 +6116,11 @@ class InstanceBootDiskInitializeParams(dict):
         """
         Indicates how much throughput to provision for the disk.
         This sets the number of throughput mb per second that the disk can handle.
-        Values must be between 1 and 7,124. Note: Updating currently is only supported
-        for hyperdisk skus via disk update api/gcloud without the need to delete and
-        recreate the disk, hyperdisk allows for an update of throughput every 4 hours.
-        To update your hyperdisk more frequently, you'll need to manually delete and recreate it.
+        For more details,see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
+        Note: Updating currently is only supported for hyperdisk skus via disk update
+        api/gcloud without the need to delete and recreate the disk, hyperdisk allows
+        for an update of throughput every 4 hours. To update your hyperdisk more
+        frequently, you'll need to manually delete and recreate it.
         """
         return pulumi.get(self, "provisioned_throughput")
 
@@ -6533,8 +6533,8 @@ class InstanceFromMachineImageBootDiskInitializeParams(dict):
         :param bool enable_confidential_compute: A flag to enable confidential compute mode on boot disk
         :param str image: The image from which this disk was initialised.
         :param Mapping[str, Any] labels: A set of key/value label pairs assigned to the disk.
-        :param int provisioned_iops: Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000.
-        :param int provisioned_throughput: Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must be between 1 and 7,124.
+        :param int provisioned_iops: Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle.
+        :param int provisioned_throughput: Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle.
         :param Mapping[str, Any] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param int size: The size of the image in gigabytes.
         :param str type: The Google Compute Engine disk type. Such as pd-standard, pd-ssd or pd-balanced.
@@ -6584,7 +6584,7 @@ class InstanceFromMachineImageBootDiskInitializeParams(dict):
     @pulumi.getter(name="provisionedIops")
     def provisioned_iops(self) -> Optional[int]:
         """
-        Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000.
+        Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle.
         """
         return pulumi.get(self, "provisioned_iops")
 
@@ -6592,7 +6592,7 @@ class InstanceFromMachineImageBootDiskInitializeParams(dict):
     @pulumi.getter(name="provisionedThroughput")
     def provisioned_throughput(self) -> Optional[int]:
         """
-        Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must be between 1 and 7,124.
+        Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle.
         """
         return pulumi.get(self, "provisioned_throughput")
 
@@ -8075,8 +8075,8 @@ class InstanceFromTemplateBootDiskInitializeParams(dict):
         :param bool enable_confidential_compute: A flag to enable confidential compute mode on boot disk
         :param str image: The image from which this disk was initialised.
         :param Mapping[str, Any] labels: A set of key/value label pairs assigned to the disk.
-        :param int provisioned_iops: Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000.
-        :param int provisioned_throughput: Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must be between 1 and 7,124.
+        :param int provisioned_iops: Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle.
+        :param int provisioned_throughput: Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle.
         :param Mapping[str, Any] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param int size: The size of the image in gigabytes.
         :param str type: The Google Compute Engine disk type. Such as pd-standard, pd-ssd or pd-balanced.
@@ -8126,7 +8126,7 @@ class InstanceFromTemplateBootDiskInitializeParams(dict):
     @pulumi.getter(name="provisionedIops")
     def provisioned_iops(self) -> Optional[int]:
         """
-        Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000.
+        Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle.
         """
         return pulumi.get(self, "provisioned_iops")
 
@@ -8134,7 +8134,7 @@ class InstanceFromTemplateBootDiskInitializeParams(dict):
     @pulumi.getter(name="provisionedThroughput")
     def provisioned_throughput(self) -> Optional[int]:
         """
-        Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must be between 1 and 7,124.
+        Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle.
         """
         return pulumi.get(self, "provisioned_throughput")
 
@@ -40967,8 +40967,8 @@ class GetInstanceBootDiskInitializeParamResult(dict):
         :param bool enable_confidential_compute: A flag to enable confidential compute mode on boot disk
         :param str image: The image from which this disk was initialised.
         :param Mapping[str, Any] labels: A set of key/value label pairs assigned to the disk.
-        :param int provisioned_iops: Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000.
-        :param int provisioned_throughput: Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must be between 1 and 7,124.
+        :param int provisioned_iops: Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle.
+        :param int provisioned_throughput: Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle.
         :param Mapping[str, Any] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param int size: The size of the image in gigabytes.
         :param str type: The accelerator type resource exposed to this instance. E.g. `nvidia-tesla-k80`.
@@ -41010,7 +41010,7 @@ class GetInstanceBootDiskInitializeParamResult(dict):
     @pulumi.getter(name="provisionedIops")
     def provisioned_iops(self) -> int:
         """
-        Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000.
+        Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle.
         """
         return pulumi.get(self, "provisioned_iops")
 
@@ -41018,7 +41018,7 @@ class GetInstanceBootDiskInitializeParamResult(dict):
     @pulumi.getter(name="provisionedThroughput")
     def provisioned_throughput(self) -> int:
         """
-        Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must be between 1 and 7,124.
+        Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle.
         """
         return pulumi.get(self, "provisioned_throughput")
 

pulumi_gcp/config/vars.py

@@ -26,7 +26,7 @@ class _ExportableConfig(types.ModuleType):
 
     @property
     def access_token(self) -> Optional[str]:
-        return __config__.get('accessToken')
+        return __config__.get('accessToken') or _utilities.get_env('GOOGLE_OAUTH_ACCESS_TOKEN')
 
     @property
     def active_directory_custom_endpoint(self) -> Optional[str]:
@@ -226,7 +226,7 @@ class _ExportableConfig(types.ModuleType):
 
     @property
     def credentials(self) -> Optional[str]:
-        return __config__.get('credentials')
+        return __config__.get('credentials') or _utilities.get_env('GOOGLE_CREDENTIALS', 'GOOGLE_CLOUD_KEYFILE_JSON', 'GCLOUD_KEYFILE_JSON')
 
     @property
     def data_catalog_custom_endpoint(self) -> Optional[str]:

pulumi_gcp/container/_inputs.py

@@ -5497,12 +5497,19 @@ class ClusterMonitoringConfigArgs:
 class ClusterMonitoringConfigAdvancedDatapathObservabilityConfigArgs:
     def __init__(__self__, *,
                  enable_metrics: pulumi.Input[bool],
+                 enable_relay: Optional[pulumi.Input[bool]] = None,
                  relay_mode: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[bool] enable_metrics: Whether or not to enable advanced datapath metrics.
+        :param pulumi.Input[bool] enable_relay: Whether or not Relay is enabled.
         :param pulumi.Input[str] relay_mode: Mode used to make Relay available.
         """
         pulumi.set(__self__, "enable_metrics", enable_metrics)
+        if enable_relay is not None:
+            pulumi.set(__self__, "enable_relay", enable_relay)
+        if relay_mode is not None:
+            warnings.warn("""Deprecated in favor of enable_relay field. Remove this attribute's configuration as this field will be removed in the next major release and enable_relay will become a required field.""", DeprecationWarning)
+            pulumi.log.warn("""relay_mode is deprecated: Deprecated in favor of enable_relay field. Remove this attribute's configuration as this field will be removed in the next major release and enable_relay will become a required field.""")
         if relay_mode is not None:
             pulumi.set(__self__, "relay_mode", relay_mode)
 
@@ -5518,12 +5525,27 @@ class ClusterMonitoringConfigAdvancedDatapathObservabilityConfigArgs:
     def enable_metrics(self, value: pulumi.Input[bool]):
         pulumi.set(self, "enable_metrics", value)
 
+    @property
+    @pulumi.getter(name="enableRelay")
+    def enable_relay(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether or not Relay is enabled.
+        """
+        return pulumi.get(self, "enable_relay")
+
+    @enable_relay.setter
+    def enable_relay(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enable_relay", value)
+
     @property
     @pulumi.getter(name="relayMode")
     def relay_mode(self) -> Optional[pulumi.Input[str]]:
         """
         Mode used to make Relay available.
         """
+        warnings.warn("""Deprecated in favor of enable_relay field. Remove this attribute's configuration as this field will be removed in the next major release and enable_relay will become a required field.""", DeprecationWarning)
+        pulumi.log.warn("""relay_mode is deprecated: Deprecated in favor of enable_relay field. Remove this attribute's configuration as this field will be removed in the next major release and enable_relay will become a required field.""")
+
         return pulumi.get(self, "relay_mode")
 
     @relay_mode.setter

pulumi_gcp/container/outputs.py

@@ -6206,6 +6206,8 @@ class ClusterMonitoringConfigAdvancedDatapathObservabilityConfig(dict):
         suggest = None
         if key == "enableMetrics":
             suggest = "enable_metrics"
+        elif key == "enableRelay":
+            suggest = "enable_relay"
         elif key == "relayMode":
             suggest = "relay_mode"
 
@@ -6222,12 +6224,16 @@ class ClusterMonitoringConfigAdvancedDatapathObservabilityConfig(dict):
 
     def __init__(__self__, *,
                  enable_metrics: bool,
+                 enable_relay: Optional[bool] = None,
                  relay_mode: Optional[str] = None):
         """
         :param bool enable_metrics: Whether or not to enable advanced datapath metrics.
+        :param bool enable_relay: Whether or not Relay is enabled.
         :param str relay_mode: Mode used to make Relay available.
         """
         pulumi.set(__self__, "enable_metrics", enable_metrics)
+        if enable_relay is not None:
+            pulumi.set(__self__, "enable_relay", enable_relay)
         if relay_mode is not None:
             pulumi.set(__self__, "relay_mode", relay_mode)
 
@@ -6239,12 +6245,23 @@ class ClusterMonitoringConfigAdvancedDatapathObservabilityConfig(dict):
         """
         return pulumi.get(self, "enable_metrics")
 
+    @property
+    @pulumi.getter(name="enableRelay")
+    def enable_relay(self) -> Optional[bool]:
+        """
+        Whether or not Relay is enabled.
+        """
+        return pulumi.get(self, "enable_relay")
+
     @property
     @pulumi.getter(name="relayMode")
     def relay_mode(self) -> Optional[str]:
         """
         Mode used to make Relay available.
         """
+        warnings.warn("""Deprecated in favor of enable_relay field. Remove this attribute's configuration as this field will be removed in the next major release and enable_relay will become a required field.""", DeprecationWarning)
+        pulumi.log.warn("""relay_mode is deprecated: Deprecated in favor of enable_relay field. Remove this attribute's configuration as this field will be removed in the next major release and enable_relay will become a required field.""")
+
         return pulumi.get(self, "relay_mode")
 
 
@@ -15096,12 +15113,15 @@ class GetClusterMonitoringConfigResult(dict):
 class GetClusterMonitoringConfigAdvancedDatapathObservabilityConfigResult(dict):
     def __init__(__self__, *,
                  enable_metrics: bool,
+                 enable_relay: bool,
                  relay_mode: str):
         """
         :param bool enable_metrics: Whether or not the advanced datapath metrics are enabled.
+        :param bool enable_relay: Whether or not Relay is enabled.
         :param str relay_mode: Mode used to make Relay available.
         """
         pulumi.set(__self__, "enable_metrics", enable_metrics)
+        pulumi.set(__self__, "enable_relay", enable_relay)
         pulumi.set(__self__, "relay_mode", relay_mode)
 
     @property
@@ -15112,6 +15132,14 @@ class GetClusterMonitoringConfigAdvancedDatapathObservabilityConfigResult(dict):
         """
         return pulumi.get(self, "enable_metrics")
 
+    @property
+    @pulumi.getter(name="enableRelay")
+    def enable_relay(self) -> bool:
+        """
+        Whether or not Relay is enabled.
+        """
+        return pulumi.get(self, "enable_relay")
+
     @property
     @pulumi.getter(name="relayMode")
     def relay_mode(self) -> str:

pulumi_gcp/dns/_inputs.py

@@ -1709,7 +1709,7 @@ class GetManagedZonesManagedZoneArgs:
         :param int managed_zone_id: Unique identifier for the resource; defined by the server.
         :param str name: A unique name for the resource.
         :param Sequence[str] name_servers: The list of nameservers that will be authoritative for this domain. Use NS records to redirect from your DNS provider to these names, thus making Google Cloud DNS authoritative for this zone.
-        :param str project: The ID of the project for the Google Cloud.
+        :param str project: The ID of the project containing Google Cloud DNS zones. If this is not provided the default project will be used.
         :param str visibility: The zone's visibility: public zones are exposed to the Internet, while private zones are visible only to Virtual Private Cloud resources.
         """
         pulumi.set(__self__, "description", description)
@@ -1797,7 +1797,7 @@ class GetManagedZonesManagedZoneArgs:
     @pulumi.getter
     def project(self) -> str:
         """
-        The ID of the project for the Google Cloud.
+        The ID of the project containing Google Cloud DNS zones. If this is not provided the default project will be used.
         """
         return pulumi.get(self, "project")
 

pulumi_gcp/dns/get_managed_zone.py

@@ -144,7 +144,7 @@ def get_managed_zone(name: Optional[str] = None,
 
 
     :param str name: A unique name for the resource.
-    :param str project: The ID of the project for the Google Cloud DNS zone.
+    :param str project: The ID of the project for the Google Cloud DNS zone.  If this is not provided the default project will be used.
     """
     __args__ = dict()
     __args__['name'] = name
@@ -189,6 +189,6 @@ def get_managed_zone_output(name: Optional[pulumi.Input[str]] = None,
 
 
     :param str name: A unique name for the resource.
-    :param str project: The ID of the project for the Google Cloud DNS zone.
+    :param str project: The ID of the project for the Google Cloud DNS zone.  If this is not provided the default project will be used.
     """
     ...

pulumi_gcp/dns/get_managed_zones.py

@@ -42,6 +42,9 @@ class GetManagedZonesResult:
     @property
     @pulumi.getter(name="managedZones")
     def managed_zones(self) -> Optional[Sequence['outputs.GetManagedZonesManagedZoneResult']]:
+        """
+        A list of managed zones.
+        """
         return pulumi.get(self, "managed_zones")
 
     @property
@@ -65,7 +68,22 @@ def get_managed_zones(managed_zones: Optional[Sequence[pulumi.InputType['GetMana
                       project: Optional[str] = None,
                       opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetManagedZonesResult:
     """
-    Use this data source to access information about an existing resource.
+    Provides access to a list of zones within Google Cloud DNS.
+    For more information see
+    [the official documentation](https://cloud.google.com/dns/zones/)
+    and
+    [API](https://cloud.google.com/dns/api/v1/managedZones).
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    zones = gcp.dns.get_managed_zones(project="my-project-id")
+    ```
+
+
+    :param Sequence[pulumi.InputType['GetManagedZonesManagedZoneArgs']] managed_zones: A list of managed zones.
+    :param str project: The ID of the project containing Google Cloud DNS zones. If this is not provided the default project will be used.
     """
     __args__ = dict()
     __args__['managedZones'] = managed_zones
@@ -84,6 +102,21 @@ def get_managed_zones_output(managed_zones: Optional[pulumi.Input[Optional[Seque
                              project: Optional[pulumi.Input[Optional[str]]] = None,
                              opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetManagedZonesResult]:
     """
-    Use this data source to access information about an existing resource.
+    Provides access to a list of zones within Google Cloud DNS.
+    For more information see
+    [the official documentation](https://cloud.google.com/dns/zones/)
+    and
+    [API](https://cloud.google.com/dns/api/v1/managedZones).
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    zones = gcp.dns.get_managed_zones(project="my-project-id")
+    ```
+
+
+    :param Sequence[pulumi.InputType['GetManagedZonesManagedZoneArgs']] managed_zones: A list of managed zones.
+    :param str project: The ID of the project containing Google Cloud DNS zones. If this is not provided the default project will be used.
     """
     ...

pulumi_gcp/dns/outputs.py

@@ -2199,7 +2199,7 @@ class GetManagedZonesManagedZoneResult(dict):
         :param int managed_zone_id: Unique identifier for the resource; defined by the server.
         :param str name: A unique name for the resource.
         :param Sequence[str] name_servers: The list of nameservers that will be authoritative for this domain. Use NS records to redirect from your DNS provider to these names, thus making Google Cloud DNS authoritative for this zone.
-        :param str project: The ID of the project for the Google Cloud.
+        :param str project: The ID of the project containing Google Cloud DNS zones. If this is not provided the default project will be used.
         :param str visibility: The zone's visibility: public zones are exposed to the Internet, while private zones are visible only to Virtual Private Cloud resources.
         """
         pulumi.set(__self__, "description", description)
@@ -2263,7 +2263,7 @@ class GetManagedZonesManagedZoneResult(dict):
     @pulumi.getter
     def project(self) -> str:
         """
-        The ID of the project for the Google Cloud.
+        The ID of the project containing Google Cloud DNS zones. If this is not provided the default project will be used.
         """
         return pulumi.get(self, "project")
 

pulumi_gcp/eventarc/_inputs.py

@@ -13,6 +13,8 @@ __all__ = [
     'TriggerDestinationArgs',
     'TriggerDestinationCloudRunServiceArgs',
     'TriggerDestinationGkeArgs',
+    'TriggerDestinationHttpEndpointArgs',
+    'TriggerDestinationNetworkConfigArgs',
     'TriggerMatchingCriteriaArgs',
     'TriggerTransportArgs',
     'TriggerTransportPubsubArgs',
@@ -24,11 +26,15 @@ class TriggerDestinationArgs:
                  cloud_function: Optional[pulumi.Input[str]] = None,
                  cloud_run_service: Optional[pulumi.Input['TriggerDestinationCloudRunServiceArgs']] = None,
                  gke: Optional[pulumi.Input['TriggerDestinationGkeArgs']] = None,
+                 http_endpoint: Optional[pulumi.Input['TriggerDestinationHttpEndpointArgs']] = None,
+                 network_config: Optional[pulumi.Input['TriggerDestinationNetworkConfigArgs']] = None,
                  workflow: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] cloud_function: The Cloud Function resource name. Only Cloud Functions V2 is supported. Format projects/{project}/locations/{location}/functions/{function} This is a read-only field. [WARNING] Creating Cloud Functions V2 triggers is only supported via the Cloud Functions product. An error will be returned if the user sets this value.
         :param pulumi.Input['TriggerDestinationCloudRunServiceArgs'] cloud_run_service: Cloud Run fully-managed service that receives the events. The service should be running in the same project of the trigger.
         :param pulumi.Input['TriggerDestinationGkeArgs'] gke: A GKE service capable of receiving events. The service should be running in the same project as the trigger.
+        :param pulumi.Input['TriggerDestinationHttpEndpointArgs'] http_endpoint: An HTTP endpoint destination described by an URI.
+        :param pulumi.Input['TriggerDestinationNetworkConfigArgs'] network_config: Optional. Network config is used to configure how Eventarc resolves and connect to a destination. This should only be used with HttpEndpoint destination type.
         :param pulumi.Input[str] workflow: The resource name of the Workflow whose Executions are triggered by the events. The Workflow resource should be deployed in the same project as the trigger. Format: `projects/{project}/locations/{location}/workflows/{workflow}`
         """
         if cloud_function is not None:
@@ -37,6 +43,10 @@ class TriggerDestinationArgs:
             pulumi.set(__self__, "cloud_run_service", cloud_run_service)
         if gke is not None:
             pulumi.set(__self__, "gke", gke)
+        if http_endpoint is not None:
+            pulumi.set(__self__, "http_endpoint", http_endpoint)
+        if network_config is not None:
+            pulumi.set(__self__, "network_config", network_config)
         if workflow is not None:
             pulumi.set(__self__, "workflow", workflow)
 
@@ -76,6 +86,30 @@ class TriggerDestinationArgs:
     def gke(self, value: Optional[pulumi.Input['TriggerDestinationGkeArgs']]):
         pulumi.set(self, "gke", value)
 
+    @property
+    @pulumi.getter(name="httpEndpoint")
+    def http_endpoint(self) -> Optional[pulumi.Input['TriggerDestinationHttpEndpointArgs']]:
+        """
+        An HTTP endpoint destination described by an URI.
+        """
+        return pulumi.get(self, "http_endpoint")
+
+    @http_endpoint.setter
+    def http_endpoint(self, value: Optional[pulumi.Input['TriggerDestinationHttpEndpointArgs']]):
+        pulumi.set(self, "http_endpoint", value)
+
+    @property
+    @pulumi.getter(name="networkConfig")
+    def network_config(self) -> Optional[pulumi.Input['TriggerDestinationNetworkConfigArgs']]:
+        """
+        Optional. Network config is used to configure how Eventarc resolves and connect to a destination. This should only be used with HttpEndpoint destination type.
+        """
+        return pulumi.get(self, "network_config")
+
+    @network_config.setter
+    def network_config(self, value: Optional[pulumi.Input['TriggerDestinationNetworkConfigArgs']]):
+        pulumi.set(self, "network_config", value)
+
     @property
     @pulumi.getter
     def workflow(self) -> Optional[pulumi.Input[str]]:
@@ -226,6 +260,50 @@ class TriggerDestinationGkeArgs:
         pulumi.set(self, "path", value)
 
 
+@pulumi.input_type
+class TriggerDestinationHttpEndpointArgs:
+    def __init__(__self__, *,
+                 uri: pulumi.Input[str]):
+        """
+        :param pulumi.Input[str] uri: Required. The URI of the HTTP enpdoint. The value must be a RFC2396 URI string. Examples: `http://10.10.10.8:80/route`, `http://svc.us-central1.p.local:8080/`. Only HTTP and HTTPS protocols are supported. The host can be either a static IP addressable from the VPC specified by the network config, or an internal DNS hostname of the service resolvable via Cloud DNS.
+        """
+        pulumi.set(__self__, "uri", uri)
+
+    @property
+    @pulumi.getter
+    def uri(self) -> pulumi.Input[str]:
+        """
+        Required. The URI of the HTTP enpdoint. The value must be a RFC2396 URI string. Examples: `http://10.10.10.8:80/route`, `http://svc.us-central1.p.local:8080/`. Only HTTP and HTTPS protocols are supported. The host can be either a static IP addressable from the VPC specified by the network config, or an internal DNS hostname of the service resolvable via Cloud DNS.
+        """
+        return pulumi.get(self, "uri")
+
+    @uri.setter
+    def uri(self, value: pulumi.Input[str]):
+        pulumi.set(self, "uri", value)
+
+
+@pulumi.input_type
+class TriggerDestinationNetworkConfigArgs:
+    def __init__(__self__, *,
+                 network_attachment: pulumi.Input[str]):
+        """
+        :param pulumi.Input[str] network_attachment: Required. Name of the NetworkAttachment that allows access to the destination VPC. Format: `projects/{PROJECT_ID}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}`
+        """
+        pulumi.set(__self__, "network_attachment", network_attachment)
+
+    @property
+    @pulumi.getter(name="networkAttachment")
+    def network_attachment(self) -> pulumi.Input[str]:
+        """
+        Required. Name of the NetworkAttachment that allows access to the destination VPC. Format: `projects/{PROJECT_ID}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}`
+        """
+        return pulumi.get(self, "network_attachment")
+
+    @network_attachment.setter
+    def network_attachment(self, value: pulumi.Input[str]):
+        pulumi.set(self, "network_attachment", value)
+
+
 @pulumi.input_type
 class TriggerMatchingCriteriaArgs:
     def __init__(__self__, *,

pulumi_gcp/eventarc/outputs.py

@@ -14,6 +14,8 @@ __all__ = [
     'TriggerDestination',
     'TriggerDestinationCloudRunService',
     'TriggerDestinationGke',
+    'TriggerDestinationHttpEndpoint',
+    'TriggerDestinationNetworkConfig',
     'TriggerMatchingCriteria',
     'TriggerTransport',
     'TriggerTransportPubsub',
@@ -28,6 +30,10 @@ class TriggerDestination(dict):
             suggest = "cloud_function"
         elif key == "cloudRunService":
             suggest = "cloud_run_service"
+        elif key == "httpEndpoint":
+            suggest = "http_endpoint"
+        elif key == "networkConfig":
+            suggest = "network_config"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in TriggerDestination. Access the value via the '{suggest}' property getter instead.")
@@ -44,11 +50,15 @@ class TriggerDestination(dict):
                  cloud_function: Optional[str] = None,
                  cloud_run_service: Optional['outputs.TriggerDestinationCloudRunService'] = None,
                  gke: Optional['outputs.TriggerDestinationGke'] = None,
+                 http_endpoint: Optional['outputs.TriggerDestinationHttpEndpoint'] = None,
+                 network_config: Optional['outputs.TriggerDestinationNetworkConfig'] = None,
                  workflow: Optional[str] = None):
         """
         :param str cloud_function: The Cloud Function resource name. Only Cloud Functions V2 is supported. Format projects/{project}/locations/{location}/functions/{function} This is a read-only field. [WARNING] Creating Cloud Functions V2 triggers is only supported via the Cloud Functions product. An error will be returned if the user sets this value.
         :param 'TriggerDestinationCloudRunServiceArgs' cloud_run_service: Cloud Run fully-managed service that receives the events. The service should be running in the same project of the trigger.
         :param 'TriggerDestinationGkeArgs' gke: A GKE service capable of receiving events. The service should be running in the same project as the trigger.
+        :param 'TriggerDestinationHttpEndpointArgs' http_endpoint: An HTTP endpoint destination described by an URI.
+        :param 'TriggerDestinationNetworkConfigArgs' network_config: Optional. Network config is used to configure how Eventarc resolves and connect to a destination. This should only be used with HttpEndpoint destination type.
         :param str workflow: The resource name of the Workflow whose Executions are triggered by the events. The Workflow resource should be deployed in the same project as the trigger. Format: `projects/{project}/locations/{location}/workflows/{workflow}`
         """
         if cloud_function is not None:
@@ -57,6 +67,10 @@ class TriggerDestination(dict):
             pulumi.set(__self__, "cloud_run_service", cloud_run_service)
         if gke is not None:
             pulumi.set(__self__, "gke", gke)
+        if http_endpoint is not None:
+            pulumi.set(__self__, "http_endpoint", http_endpoint)
+        if network_config is not None:
+            pulumi.set(__self__, "network_config", network_config)
         if workflow is not None:
             pulumi.set(__self__, "workflow", workflow)
 
@@ -84,6 +98,22 @@ class TriggerDestination(dict):
         """
         return pulumi.get(self, "gke")
 
+    @property
+    @pulumi.getter(name="httpEndpoint")
+    def http_endpoint(self) -> Optional['outputs.TriggerDestinationHttpEndpoint']:
+        """
+        An HTTP endpoint destination described by an URI.
+        """
+        return pulumi.get(self, "http_endpoint")
+
+    @property
+    @pulumi.getter(name="networkConfig")
+    def network_config(self) -> Optional['outputs.TriggerDestinationNetworkConfig']:
+        """
+        Optional. Network config is used to configure how Eventarc resolves and connect to a destination. This should only be used with HttpEndpoint destination type.
+        """
+        return pulumi.get(self, "network_config")
+
     @property
     @pulumi.getter
     def workflow(self) -> Optional[str]:
@@ -198,6 +228,59 @@ class TriggerDestinationGke(dict):
         return pulumi.get(self, "path")
 
 
+@pulumi.output_type
+class TriggerDestinationHttpEndpoint(dict):
+    def __init__(__self__, *,
+                 uri: str):
+        """
+        :param str uri: Required. The URI of the HTTP enpdoint. The value must be a RFC2396 URI string. Examples: `http://10.10.10.8:80/route`, `http://svc.us-central1.p.local:8080/`. Only HTTP and HTTPS protocols are supported. The host can be either a static IP addressable from the VPC specified by the network config, or an internal DNS hostname of the service resolvable via Cloud DNS.
+        """
+        pulumi.set(__self__, "uri", uri)
+
+    @property
+    @pulumi.getter
+    def uri(self) -> str:
+        """
+        Required. The URI of the HTTP enpdoint. The value must be a RFC2396 URI string. Examples: `http://10.10.10.8:80/route`, `http://svc.us-central1.p.local:8080/`. Only HTTP and HTTPS protocols are supported. The host can be either a static IP addressable from the VPC specified by the network config, or an internal DNS hostname of the service resolvable via Cloud DNS.
+        """
+        return pulumi.get(self, "uri")
+
+
+@pulumi.output_type
+class TriggerDestinationNetworkConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "networkAttachment":
+            suggest = "network_attachment"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TriggerDestinationNetworkConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TriggerDestinationNetworkConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TriggerDestinationNetworkConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 network_attachment: str):
+        """
+        :param str network_attachment: Required. Name of the NetworkAttachment that allows access to the destination VPC. Format: `projects/{PROJECT_ID}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}`
+        """
+        pulumi.set(__self__, "network_attachment", network_attachment)
+
+    @property
+    @pulumi.getter(name="networkAttachment")
+    def network_attachment(self) -> str:
+        """
+        Required. Name of the NetworkAttachment that allows access to the destination VPC. Format: `projects/{PROJECT_ID}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}`
+        """
+        return pulumi.get(self, "network_attachment")
+
+
 @pulumi.output_type
 class TriggerMatchingCriteria(dict):
     def __init__(__self__, *,