pulumi-gcp 8.30.1a1747132587__py3-none-any.whl → 8.31.0__py3-none-any.whl

pulumi_gcp/__init__.py

@@ -2574,6 +2574,14 @@ _utilities.register(
    "gcp:compute/caExternalAccountKey:CaExternalAccountKey": "CaExternalAccountKey"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "compute/crossSiteNetwork",
+  "fqn": "pulumi_gcp.compute",
+  "classes": {
+   "gcp:compute/crossSiteNetwork:CrossSiteNetwork": "CrossSiteNetwork"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "compute/disk",

pulumi_gcp/alloydb/_inputs.py

@@ -84,6 +84,8 @@ __all__ = [
     'InstanceObservabilityConfigArgsDict',
     'InstancePscInstanceConfigArgs',
     'InstancePscInstanceConfigArgsDict',
+    'InstancePscInstanceConfigPscAutoConnectionArgs',
+    'InstancePscInstanceConfigPscAutoConnectionArgsDict',
     'InstancePscInstanceConfigPscInterfaceConfigArgs',
     'InstancePscInstanceConfigPscInterfaceConfigArgsDict',
     'InstanceQueryInsightsConfigArgs',
@@ -2174,6 +2176,11 @@ if not MYPY:
         List of consumer projects that are allowed to create PSC endpoints to service-attachments to this instance.
         These should be specified as project numbers only.
         """
+        psc_auto_connections: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscAutoConnectionArgsDict']]]]
+        """
+        Configurations for setting up PSC service automation.
+        Structure is documented below.
+        """
         psc_dns_name: NotRequired[pulumi.Input[builtins.str]]
         """
         (Output)
@@ -2200,12 +2207,15 @@ elif False:
 class InstancePscInstanceConfigArgs:
     def __init__(__self__, *,
                  allowed_consumer_projects: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
+                 psc_auto_connections: Optional[pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscAutoConnectionArgs']]]] = None,
                  psc_dns_name: Optional[pulumi.Input[builtins.str]] = None,
                  psc_interface_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscInterfaceConfigArgs']]]] = None,
                  service_attachment_link: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allowed_consumer_projects: List of consumer projects that are allowed to create PSC endpoints to service-attachments to this instance.
                These should be specified as project numbers only.
+        :param pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscAutoConnectionArgs']]] psc_auto_connections: Configurations for setting up PSC service automation.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] psc_dns_name: (Output)
                The DNS name of the instance for PSC connectivity.
                Name convention: <uid>.<uid>.<region>.alloydb-psc.goog
@@ -2219,6 +2229,8 @@ class InstancePscInstanceConfigArgs:
         """
         if allowed_consumer_projects is not None:
             pulumi.set(__self__, "allowed_consumer_projects", allowed_consumer_projects)
+        if psc_auto_connections is not None:
+            pulumi.set(__self__, "psc_auto_connections", psc_auto_connections)
         if psc_dns_name is not None:
             pulumi.set(__self__, "psc_dns_name", psc_dns_name)
         if psc_interface_configs is not None:
@@ -2239,6 +2251,19 @@ class InstancePscInstanceConfigArgs:
     def allowed_consumer_projects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
         pulumi.set(self, "allowed_consumer_projects", value)
 
+    @property
+    @pulumi.getter(name="pscAutoConnections")
+    def psc_auto_connections(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscAutoConnectionArgs']]]]:
+        """
+        Configurations for setting up PSC service automation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "psc_auto_connections")
+
+    @psc_auto_connections.setter
+    def psc_auto_connections(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscAutoConnectionArgs']]]]):
+        pulumi.set(self, "psc_auto_connections", value)
+
     @property
     @pulumi.getter(name="pscDnsName")
     def psc_dns_name(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -2283,6 +2308,145 @@ class InstancePscInstanceConfigArgs:
         pulumi.set(self, "service_attachment_link", value)
 
 
+if not MYPY:
+    class InstancePscInstanceConfigPscAutoConnectionArgsDict(TypedDict):
+        consumer_network: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The consumer network for the PSC service automation, example:
+        "projects/vpc-host-project/global/networks/default".
+        The consumer network might be hosted a different project than the
+        consumer project. The API expects the consumer project specified to be
+        the project ID (and not the project number)
+        """
+        consumer_network_status: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        The status of the service connection policy.
+        """
+        consumer_project: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The consumer project to which the PSC service automation endpoint will
+        be created. The API expects the consumer project to be the project ID(
+        and not the project number).
+        """
+        ip_address: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        The IP address of the PSC service automation endpoint.
+        """
+        status: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        The status of the PSC service automation connection.
+        """
+elif False:
+    InstancePscInstanceConfigPscAutoConnectionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstancePscInstanceConfigPscAutoConnectionArgs:
+    def __init__(__self__, *,
+                 consumer_network: Optional[pulumi.Input[builtins.str]] = None,
+                 consumer_network_status: Optional[pulumi.Input[builtins.str]] = None,
+                 consumer_project: Optional[pulumi.Input[builtins.str]] = None,
+                 ip_address: Optional[pulumi.Input[builtins.str]] = None,
+                 status: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] consumer_network: The consumer network for the PSC service automation, example:
+               "projects/vpc-host-project/global/networks/default".
+               The consumer network might be hosted a different project than the
+               consumer project. The API expects the consumer project specified to be
+               the project ID (and not the project number)
+        :param pulumi.Input[builtins.str] consumer_network_status: (Output)
+               The status of the service connection policy.
+        :param pulumi.Input[builtins.str] consumer_project: The consumer project to which the PSC service automation endpoint will
+               be created. The API expects the consumer project to be the project ID(
+               and not the project number).
+        :param pulumi.Input[builtins.str] ip_address: (Output)
+               The IP address of the PSC service automation endpoint.
+        :param pulumi.Input[builtins.str] status: (Output)
+               The status of the PSC service automation connection.
+        """
+        if consumer_network is not None:
+            pulumi.set(__self__, "consumer_network", consumer_network)
+        if consumer_network_status is not None:
+            pulumi.set(__self__, "consumer_network_status", consumer_network_status)
+        if consumer_project is not None:
+            pulumi.set(__self__, "consumer_project", consumer_project)
+        if ip_address is not None:
+            pulumi.set(__self__, "ip_address", ip_address)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="consumerNetwork")
+    def consumer_network(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The consumer network for the PSC service automation, example:
+        "projects/vpc-host-project/global/networks/default".
+        The consumer network might be hosted a different project than the
+        consumer project. The API expects the consumer project specified to be
+        the project ID (and not the project number)
+        """
+        return pulumi.get(self, "consumer_network")
+
+    @consumer_network.setter
+    def consumer_network(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "consumer_network", value)
+
+    @property
+    @pulumi.getter(name="consumerNetworkStatus")
+    def consumer_network_status(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        The status of the service connection policy.
+        """
+        return pulumi.get(self, "consumer_network_status")
+
+    @consumer_network_status.setter
+    def consumer_network_status(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "consumer_network_status", value)
+
+    @property
+    @pulumi.getter(name="consumerProject")
+    def consumer_project(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The consumer project to which the PSC service automation endpoint will
+        be created. The API expects the consumer project to be the project ID(
+        and not the project number).
+        """
+        return pulumi.get(self, "consumer_project")
+
+    @consumer_project.setter
+    def consumer_project(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "consumer_project", value)
+
+    @property
+    @pulumi.getter(name="ipAddress")
+    def ip_address(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        The IP address of the PSC service automation endpoint.
+        """
+        return pulumi.get(self, "ip_address")
+
+    @ip_address.setter
+    def ip_address(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "ip_address", value)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        The status of the PSC service automation connection.
+        """
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "status", value)
+
+
 if not MYPY:
     class InstancePscInstanceConfigPscInterfaceConfigArgsDict(TypedDict):
         network_attachment_resource: NotRequired[pulumi.Input[builtins.str]]

pulumi_gcp/alloydb/outputs.py

@@ -51,6 +51,7 @@ __all__ = [
     'InstanceNetworkConfigAuthorizedExternalNetwork',
     'InstanceObservabilityConfig',
     'InstancePscInstanceConfig',
+    'InstancePscInstanceConfigPscAutoConnection',
     'InstancePscInstanceConfigPscInterfaceConfig',
     'InstanceQueryInsightsConfig',
     'InstanceReadPoolConfig',
@@ -85,6 +86,7 @@ __all__ = [
     'GetInstanceNetworkConfigAuthorizedExternalNetworkResult',
     'GetInstanceObservabilityConfigResult',
     'GetInstancePscInstanceConfigResult',
+    'GetInstancePscInstanceConfigPscAutoConnectionResult',
     'GetInstancePscInstanceConfigPscInterfaceConfigResult',
     'GetInstanceQueryInsightsConfigResult',
     'GetInstanceReadPoolConfigResult',
@@ -1894,6 +1896,8 @@ class InstancePscInstanceConfig(dict):
         suggest = None
         if key == "allowedConsumerProjects":
             suggest = "allowed_consumer_projects"
+        elif key == "pscAutoConnections":
+            suggest = "psc_auto_connections"
         elif key == "pscDnsName":
             suggest = "psc_dns_name"
         elif key == "pscInterfaceConfigs":
@@ -1914,12 +1918,15 @@ class InstancePscInstanceConfig(dict):
 
     def __init__(__self__, *,
                  allowed_consumer_projects: Optional[Sequence[builtins.str]] = None,
+                 psc_auto_connections: Optional[Sequence['outputs.InstancePscInstanceConfigPscAutoConnection']] = None,
                  psc_dns_name: Optional[builtins.str] = None,
                  psc_interface_configs: Optional[Sequence['outputs.InstancePscInstanceConfigPscInterfaceConfig']] = None,
                  service_attachment_link: Optional[builtins.str] = None):
         """
         :param Sequence[builtins.str] allowed_consumer_projects: List of consumer projects that are allowed to create PSC endpoints to service-attachments to this instance.
                These should be specified as project numbers only.
+        :param Sequence['InstancePscInstanceConfigPscAutoConnectionArgs'] psc_auto_connections: Configurations for setting up PSC service automation.
+               Structure is documented below.
         :param builtins.str psc_dns_name: (Output)
                The DNS name of the instance for PSC connectivity.
                Name convention: <uid>.<uid>.<region>.alloydb-psc.goog
@@ -1933,6 +1940,8 @@ class InstancePscInstanceConfig(dict):
         """
         if allowed_consumer_projects is not None:
             pulumi.set(__self__, "allowed_consumer_projects", allowed_consumer_projects)
+        if psc_auto_connections is not None:
+            pulumi.set(__self__, "psc_auto_connections", psc_auto_connections)
         if psc_dns_name is not None:
             pulumi.set(__self__, "psc_dns_name", psc_dns_name)
         if psc_interface_configs is not None:
@@ -1949,6 +1958,15 @@ class InstancePscInstanceConfig(dict):
         """
         return pulumi.get(self, "allowed_consumer_projects")
 
+    @property
+    @pulumi.getter(name="pscAutoConnections")
+    def psc_auto_connections(self) -> Optional[Sequence['outputs.InstancePscInstanceConfigPscAutoConnection']]:
+        """
+        Configurations for setting up PSC service automation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "psc_auto_connections")
+
     @property
     @pulumi.getter(name="pscDnsName")
     def psc_dns_name(self) -> Optional[builtins.str]:
@@ -1981,6 +1999,114 @@ class InstancePscInstanceConfig(dict):
         return pulumi.get(self, "service_attachment_link")
 
 
+@pulumi.output_type
+class InstancePscInstanceConfigPscAutoConnection(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "consumerNetwork":
+            suggest = "consumer_network"
+        elif key == "consumerNetworkStatus":
+            suggest = "consumer_network_status"
+        elif key == "consumerProject":
+            suggest = "consumer_project"
+        elif key == "ipAddress":
+            suggest = "ip_address"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstancePscInstanceConfigPscAutoConnection. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstancePscInstanceConfigPscAutoConnection.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstancePscInstanceConfigPscAutoConnection.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 consumer_network: Optional[builtins.str] = None,
+                 consumer_network_status: Optional[builtins.str] = None,
+                 consumer_project: Optional[builtins.str] = None,
+                 ip_address: Optional[builtins.str] = None,
+                 status: Optional[builtins.str] = None):
+        """
+        :param builtins.str consumer_network: The consumer network for the PSC service automation, example:
+               "projects/vpc-host-project/global/networks/default".
+               The consumer network might be hosted a different project than the
+               consumer project. The API expects the consumer project specified to be
+               the project ID (and not the project number)
+        :param builtins.str consumer_network_status: (Output)
+               The status of the service connection policy.
+        :param builtins.str consumer_project: The consumer project to which the PSC service automation endpoint will
+               be created. The API expects the consumer project to be the project ID(
+               and not the project number).
+        :param builtins.str ip_address: (Output)
+               The IP address of the PSC service automation endpoint.
+        :param builtins.str status: (Output)
+               The status of the PSC service automation connection.
+        """
+        if consumer_network is not None:
+            pulumi.set(__self__, "consumer_network", consumer_network)
+        if consumer_network_status is not None:
+            pulumi.set(__self__, "consumer_network_status", consumer_network_status)
+        if consumer_project is not None:
+            pulumi.set(__self__, "consumer_project", consumer_project)
+        if ip_address is not None:
+            pulumi.set(__self__, "ip_address", ip_address)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="consumerNetwork")
+    def consumer_network(self) -> Optional[builtins.str]:
+        """
+        The consumer network for the PSC service automation, example:
+        "projects/vpc-host-project/global/networks/default".
+        The consumer network might be hosted a different project than the
+        consumer project. The API expects the consumer project specified to be
+        the project ID (and not the project number)
+        """
+        return pulumi.get(self, "consumer_network")
+
+    @property
+    @pulumi.getter(name="consumerNetworkStatus")
+    def consumer_network_status(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        The status of the service connection policy.
+        """
+        return pulumi.get(self, "consumer_network_status")
+
+    @property
+    @pulumi.getter(name="consumerProject")
+    def consumer_project(self) -> Optional[builtins.str]:
+        """
+        The consumer project to which the PSC service automation endpoint will
+        be created. The API expects the consumer project to be the project ID(
+        and not the project number).
+        """
+        return pulumi.get(self, "consumer_project")
+
+    @property
+    @pulumi.getter(name="ipAddress")
+    def ip_address(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        The IP address of the PSC service automation endpoint.
+        """
+        return pulumi.get(self, "ip_address")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        The status of the PSC service automation connection.
+        """
+        return pulumi.get(self, "status")
+
+
 @pulumi.output_type
 class InstancePscInstanceConfigPscInterfaceConfig(dict):
     @staticmethod
@@ -3188,12 +3314,14 @@ class GetInstanceObservabilityConfigResult(dict):
 class GetInstancePscInstanceConfigResult(dict):
     def __init__(__self__, *,
                  allowed_consumer_projects: Sequence[builtins.str],
+                 psc_auto_connections: Sequence['outputs.GetInstancePscInstanceConfigPscAutoConnectionResult'],
                  psc_dns_name: builtins.str,
                  psc_interface_configs: Sequence['outputs.GetInstancePscInstanceConfigPscInterfaceConfigResult'],
                  service_attachment_link: builtins.str):
         """
         :param Sequence[builtins.str] allowed_consumer_projects: List of consumer projects that are allowed to create PSC endpoints to service-attachments to this instance.
                These should be specified as project numbers only.
+        :param Sequence['GetInstancePscInstanceConfigPscAutoConnectionArgs'] psc_auto_connections: Configurations for setting up PSC service automation.
         :param builtins.str psc_dns_name: The DNS name of the instance for PSC connectivity.
                Name convention: <uid>.<uid>.<region>.alloydb-psc.goog
         :param Sequence['GetInstancePscInstanceConfigPscInterfaceConfigArgs'] psc_interface_configs: Configurations for setting up PSC interfaces attached to the instance
@@ -3203,6 +3331,7 @@ class GetInstancePscInstanceConfigResult(dict):
                'projects/<alloydb-tenant-project-number>/regions/<region-name>/serviceAttachments/<service-attachment-name>'
         """
         pulumi.set(__self__, "allowed_consumer_projects", allowed_consumer_projects)
+        pulumi.set(__self__, "psc_auto_connections", psc_auto_connections)
         pulumi.set(__self__, "psc_dns_name", psc_dns_name)
         pulumi.set(__self__, "psc_interface_configs", psc_interface_configs)
         pulumi.set(__self__, "service_attachment_link", service_attachment_link)
@@ -3216,6 +3345,14 @@ class GetInstancePscInstanceConfigResult(dict):
         """
         return pulumi.get(self, "allowed_consumer_projects")
 
+    @property
+    @pulumi.getter(name="pscAutoConnections")
+    def psc_auto_connections(self) -> Sequence['outputs.GetInstancePscInstanceConfigPscAutoConnectionResult']:
+        """
+        Configurations for setting up PSC service automation.
+        """
+        return pulumi.get(self, "psc_auto_connections")
+
     @property
     @pulumi.getter(name="pscDnsName")
     def psc_dns_name(self) -> builtins.str:
@@ -3245,6 +3382,80 @@ class GetInstancePscInstanceConfigResult(dict):
         return pulumi.get(self, "service_attachment_link")
 
 
+@pulumi.output_type
+class GetInstancePscInstanceConfigPscAutoConnectionResult(dict):
+    def __init__(__self__, *,
+                 consumer_network: builtins.str,
+                 consumer_network_status: builtins.str,
+                 consumer_project: builtins.str,
+                 ip_address: builtins.str,
+                 status: builtins.str):
+        """
+        :param builtins.str consumer_network: The consumer network for the PSC service automation, example:
+               "projects/vpc-host-project/global/networks/default".
+               The consumer network might be hosted a different project than the
+               consumer project. The API expects the consumer project specified to be
+               the project ID (and not the project number)
+        :param builtins.str consumer_network_status: The status of the service connection policy.
+        :param builtins.str consumer_project: The consumer project to which the PSC service automation endpoint will
+               be created. The API expects the consumer project to be the project ID(
+               and not the project number).
+        :param builtins.str ip_address: The IP address of the PSC service automation endpoint.
+        :param builtins.str status: The status of the PSC service automation connection.
+        """
+        pulumi.set(__self__, "consumer_network", consumer_network)
+        pulumi.set(__self__, "consumer_network_status", consumer_network_status)
+        pulumi.set(__self__, "consumer_project", consumer_project)
+        pulumi.set(__self__, "ip_address", ip_address)
+        pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="consumerNetwork")
+    def consumer_network(self) -> builtins.str:
+        """
+        The consumer network for the PSC service automation, example:
+        "projects/vpc-host-project/global/networks/default".
+        The consumer network might be hosted a different project than the
+        consumer project. The API expects the consumer project specified to be
+        the project ID (and not the project number)
+        """
+        return pulumi.get(self, "consumer_network")
+
+    @property
+    @pulumi.getter(name="consumerNetworkStatus")
+    def consumer_network_status(self) -> builtins.str:
+        """
+        The status of the service connection policy.
+        """
+        return pulumi.get(self, "consumer_network_status")
+
+    @property
+    @pulumi.getter(name="consumerProject")
+    def consumer_project(self) -> builtins.str:
+        """
+        The consumer project to which the PSC service automation endpoint will
+        be created. The API expects the consumer project to be the project ID(
+        and not the project number).
+        """
+        return pulumi.get(self, "consumer_project")
+
+    @property
+    @pulumi.getter(name="ipAddress")
+    def ip_address(self) -> builtins.str:
+        """
+        The IP address of the PSC service automation endpoint.
+        """
+        return pulumi.get(self, "ip_address")
+
+    @property
+    @pulumi.getter
+    def status(self) -> builtins.str:
+        """
+        The status of the PSC service automation connection.
+        """
+        return pulumi.get(self, "status")
+
+
 @pulumi.output_type
 class GetInstancePscInstanceConfigPscInterfaceConfigResult(dict):
     def __init__(__self__, *,

pulumi_gcp/apigee/_inputs.py

@@ -2259,6 +2259,10 @@ if not MYPY:
         The TLS Common Name of the certificate.
         Structure is documented below.
         """
+        enforce: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        If true, TLS is strictly enforced.
+        """
         ignore_validation_errors: NotRequired[pulumi.Input[builtins.bool]]
         """
         If true, Edge ignores TLS certificate errors. Valid when configuring TLS for target servers and target endpoints, and when configuring virtual hosts that use 2-way TLS. When used with a target endpoint/target server, if the backend system uses SNI and returns a cert with a subject Distinguished Name (DN) that does not match the hostname, there is no way to ignore the error and the connection fails.
@@ -2289,6 +2293,7 @@ class TargetServerSSlInfoArgs:
                  ciphers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                  client_auth_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                  common_name: Optional[pulumi.Input['TargetServerSSlInfoCommonNameArgs']] = None,
+                 enforce: Optional[pulumi.Input[builtins.bool]] = None,
                  ignore_validation_errors: Optional[pulumi.Input[builtins.bool]] = None,
                  key_alias: Optional[pulumi.Input[builtins.str]] = None,
                  key_store: Optional[pulumi.Input[builtins.str]] = None,
@@ -2300,6 +2305,7 @@ class TargetServerSSlInfoArgs:
         :param pulumi.Input[builtins.bool] client_auth_enabled: Enables two-way TLS.
         :param pulumi.Input['TargetServerSSlInfoCommonNameArgs'] common_name: The TLS Common Name of the certificate.
                Structure is documented below.
+        :param pulumi.Input[builtins.bool] enforce: If true, TLS is strictly enforced.
         :param pulumi.Input[builtins.bool] ignore_validation_errors: If true, Edge ignores TLS certificate errors. Valid when configuring TLS for target servers and target endpoints, and when configuring virtual hosts that use 2-way TLS. When used with a target endpoint/target server, if the backend system uses SNI and returns a cert with a subject Distinguished Name (DN) that does not match the hostname, there is no way to ignore the error and the connection fails.
         :param pulumi.Input[builtins.str] key_alias: Required if clientAuthEnabled is true. The resource ID for the alias containing the private key and cert.
         :param pulumi.Input[builtins.str] key_store: Required if clientAuthEnabled is true. The resource ID of the keystore.
@@ -2313,6 +2319,8 @@ class TargetServerSSlInfoArgs:
             pulumi.set(__self__, "client_auth_enabled", client_auth_enabled)
         if common_name is not None:
             pulumi.set(__self__, "common_name", common_name)
+        if enforce is not None:
+            pulumi.set(__self__, "enforce", enforce)
         if ignore_validation_errors is not None:
             pulumi.set(__self__, "ignore_validation_errors", ignore_validation_errors)
         if key_alias is not None:
@@ -2373,6 +2381,18 @@ class TargetServerSSlInfoArgs:
     def common_name(self, value: Optional[pulumi.Input['TargetServerSSlInfoCommonNameArgs']]):
         pulumi.set(self, "common_name", value)
 
+    @property
+    @pulumi.getter
+    def enforce(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        If true, TLS is strictly enforced.
+        """
+        return pulumi.get(self, "enforce")
+
+    @enforce.setter
+    def enforce(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "enforce", value)
+
     @property
     @pulumi.getter(name="ignoreValidationErrors")
     def ignore_validation_errors(self) -> Optional[pulumi.Input[builtins.bool]]:

pulumi_gcp/apigee/outputs.py

@@ -1706,6 +1706,7 @@ class TargetServerSSlInfo(dict):
                  ciphers: Optional[Sequence[builtins.str]] = None,
                  client_auth_enabled: Optional[builtins.bool] = None,
                  common_name: Optional['outputs.TargetServerSSlInfoCommonName'] = None,
+                 enforce: Optional[builtins.bool] = None,
                  ignore_validation_errors: Optional[builtins.bool] = None,
                  key_alias: Optional[builtins.str] = None,
                  key_store: Optional[builtins.str] = None,
@@ -1717,6 +1718,7 @@ class TargetServerSSlInfo(dict):
         :param builtins.bool client_auth_enabled: Enables two-way TLS.
         :param 'TargetServerSSlInfoCommonNameArgs' common_name: The TLS Common Name of the certificate.
                Structure is documented below.
+        :param builtins.bool enforce: If true, TLS is strictly enforced.
         :param builtins.bool ignore_validation_errors: If true, Edge ignores TLS certificate errors. Valid when configuring TLS for target servers and target endpoints, and when configuring virtual hosts that use 2-way TLS. When used with a target endpoint/target server, if the backend system uses SNI and returns a cert with a subject Distinguished Name (DN) that does not match the hostname, there is no way to ignore the error and the connection fails.
         :param builtins.str key_alias: Required if clientAuthEnabled is true. The resource ID for the alias containing the private key and cert.
         :param builtins.str key_store: Required if clientAuthEnabled is true. The resource ID of the keystore.
@@ -1730,6 +1732,8 @@ class TargetServerSSlInfo(dict):
             pulumi.set(__self__, "client_auth_enabled", client_auth_enabled)
         if common_name is not None:
             pulumi.set(__self__, "common_name", common_name)
+        if enforce is not None:
+            pulumi.set(__self__, "enforce", enforce)
         if ignore_validation_errors is not None:
             pulumi.set(__self__, "ignore_validation_errors", ignore_validation_errors)
         if key_alias is not None:
@@ -1774,6 +1778,14 @@ class TargetServerSSlInfo(dict):
         """
         return pulumi.get(self, "common_name")
 
+    @property
+    @pulumi.getter
+    def enforce(self) -> Optional[builtins.bool]:
+        """
+        If true, TLS is strictly enforced.
+        """
+        return pulumi.get(self, "enforce")
+
     @property
     @pulumi.getter(name="ignoreValidationErrors")
     def ignore_validation_errors(self) -> Optional[builtins.bool]: