pulumi-gcp 8.37.0a1751903932__py3-none-any.whl → 8.39.0a1752699425__py3-none-any.whl

pulumi_gcp/networkservices/edge_cache_service.py

@@ -39,28 +39,28 @@ class EdgeCacheServiceArgs:
         :param pulumi.Input['EdgeCacheServiceRoutingArgs'] routing: Defines how requests are routed, modified, cached and/or which origin content is filled from.
                Structure is documented below.
         :param pulumi.Input[builtins.str] description: A human-readable description of the resource.
-        :param pulumi.Input[builtins.bool] disable_http2: Disables HTTP/2. HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use
-               and reduces connection setup overhead by sending multiple streams over the same connection. Some legacy HTTP clients may
-               have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from
-               being advertised and negotiated.
+        :param pulumi.Input[builtins.bool] disable_http2: Disables HTTP/2.
+               HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use and reduces connection setup overhead by sending multiple streams over the same connection.
+               Some legacy HTTP clients may have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from being advertised and negotiated.
         :param pulumi.Input[builtins.bool] disable_quic: HTTP/3 (IETF QUIC) and Google QUIC are enabled by default.
-        :param pulumi.Input[builtins.str] edge_security_policy: Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the
-               EdgeCacheService.
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] edge_ssl_certificates: URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService. Note
-               that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
-        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Set of label tags associated with the EdgeCache resource. **Note**: This field is non-authoritative, and will only
-               manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
-               present on the resource.
-        :param pulumi.Input['EdgeCacheServiceLogConfigArgs'] log_config: Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to
-               Cloud Logging.
+        :param pulumi.Input[builtins.str] edge_security_policy: Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] edge_ssl_certificates: URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService.
+               Note that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
+        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Set of label tags associated with the EdgeCache resource.
+               **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+               Please refer to the field `effective_labels` for all of the labels present on the resource.
+        :param pulumi.Input['EdgeCacheServiceLogConfigArgs'] log_config: Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to Cloud Logging.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource; provided by the client when the resource is created.
                The name must be 1-64 characters long, and match the regular expression [a-zA-Z][a-zA-Z0-9_-]* which means the first character must be a letter,
                and all following characters must be a dash, underscore, letter or digit.
-        :param pulumi.Input[builtins.bool] require_tls: Require TLS (HTTPS) for all clients connecting to this service. Clients who connect over HTTP (port 80) will receive a
-               HTTP 301 to the same URL over HTTPS (port 443). You must have at least one (1) edgeSslCertificate specified to enable
-               this.
-        :param pulumi.Input[builtins.str] ssl_policy: URL of the SslPolicy resource that will be associated with the EdgeCacheService. If not set, the EdgeCacheService has no
-               SSL policy configured, and will default to the "COMPATIBLE" policy.
+        :param pulumi.Input[builtins.str] project: The ID of the project in which the resource belongs.
+               If it is not provided, the provider project is used.
+        :param pulumi.Input[builtins.bool] require_tls: Require TLS (HTTPS) for all clients connecting to this service.
+               Clients who connect over HTTP (port 80) will receive a HTTP 301 to the same URL over HTTPS (port 443).
+               You must have at least one (1) edgeSslCertificate specified to enable this.
+        :param pulumi.Input[builtins.str] ssl_policy: URL of the SslPolicy resource that will be associated with the EdgeCacheService.
+               If not set, the EdgeCacheService has no SSL policy configured, and will default to the "COMPATIBLE" policy.
         """
         pulumi.set(__self__, "routing", routing)
         if description is not None:
@@ -115,10 +115,9 @@ class EdgeCacheServiceArgs:
     @pulumi.getter(name="disableHttp2")
     def disable_http2(self) -> Optional[pulumi.Input[builtins.bool]]:
         """
-        Disables HTTP/2. HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use
-        and reduces connection setup overhead by sending multiple streams over the same connection. Some legacy HTTP clients may
-        have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from
-        being advertised and negotiated.
+        Disables HTTP/2.
+        HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use and reduces connection setup overhead by sending multiple streams over the same connection.
+        Some legacy HTTP clients may have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from being advertised and negotiated.
         """
         return pulumi.get(self, "disable_http2")
 
@@ -142,8 +141,7 @@ class EdgeCacheServiceArgs:
     @pulumi.getter(name="edgeSecurityPolicy")
     def edge_security_policy(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the
-        EdgeCacheService.
+        Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.
         """
         return pulumi.get(self, "edge_security_policy")
 
@@ -155,8 +153,8 @@ class EdgeCacheServiceArgs:
     @pulumi.getter(name="edgeSslCertificates")
     def edge_ssl_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
         """
-        URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService. Note
-        that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
+        URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService.
+        Note that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
         """
         return pulumi.get(self, "edge_ssl_certificates")
 
@@ -168,9 +166,9 @@ class EdgeCacheServiceArgs:
     @pulumi.getter
     def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
         """
-        Set of label tags associated with the EdgeCache resource. **Note**: This field is non-authoritative, and will only
-        manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
-        present on the resource.
+        Set of label tags associated with the EdgeCache resource.
+        **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+        Please refer to the field `effective_labels` for all of the labels present on the resource.
         """
         return pulumi.get(self, "labels")
 
@@ -182,8 +180,8 @@ class EdgeCacheServiceArgs:
     @pulumi.getter(name="logConfig")
     def log_config(self) -> Optional[pulumi.Input['EdgeCacheServiceLogConfigArgs']]:
         """
-        Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to
-        Cloud Logging.
+        Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to Cloud Logging.
+        Structure is documented below.
         """
         return pulumi.get(self, "log_config")
 
@@ -208,6 +206,10 @@ class EdgeCacheServiceArgs:
     @property
     @pulumi.getter
     def project(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The ID of the project in which the resource belongs.
+        If it is not provided, the provider project is used.
+        """
         return pulumi.get(self, "project")
 
     @project.setter
@@ -218,9 +220,9 @@ class EdgeCacheServiceArgs:
     @pulumi.getter(name="requireTls")
     def require_tls(self) -> Optional[pulumi.Input[builtins.bool]]:
         """
-        Require TLS (HTTPS) for all clients connecting to this service. Clients who connect over HTTP (port 80) will receive a
-        HTTP 301 to the same URL over HTTPS (port 443). You must have at least one (1) edgeSslCertificate specified to enable
-        this.
+        Require TLS (HTTPS) for all clients connecting to this service.
+        Clients who connect over HTTP (port 80) will receive a HTTP 301 to the same URL over HTTPS (port 443).
+        You must have at least one (1) edgeSslCertificate specified to enable this.
         """
         return pulumi.get(self, "require_tls")
 
@@ -232,8 +234,8 @@ class EdgeCacheServiceArgs:
     @pulumi.getter(name="sslPolicy")
     def ssl_policy(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        URL of the SslPolicy resource that will be associated with the EdgeCacheService. If not set, the EdgeCacheService has no
-        SSL policy configured, and will default to the "COMPATIBLE" policy.
+        URL of the SslPolicy resource that will be associated with the EdgeCacheService.
+        If not set, the EdgeCacheService has no SSL policy configured, and will default to the "COMPATIBLE" policy.
         """
         return pulumi.get(self, "ssl_policy")
 
@@ -264,35 +266,35 @@ class _EdgeCacheServiceState:
         """
         Input properties used for looking up and filtering EdgeCacheService resources.
         :param pulumi.Input[builtins.str] description: A human-readable description of the resource.
-        :param pulumi.Input[builtins.bool] disable_http2: Disables HTTP/2. HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use
-               and reduces connection setup overhead by sending multiple streams over the same connection. Some legacy HTTP clients may
-               have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from
-               being advertised and negotiated.
+        :param pulumi.Input[builtins.bool] disable_http2: Disables HTTP/2.
+               HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use and reduces connection setup overhead by sending multiple streams over the same connection.
+               Some legacy HTTP clients may have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from being advertised and negotiated.
         :param pulumi.Input[builtins.bool] disable_quic: HTTP/3 (IETF QUIC) and Google QUIC are enabled by default.
-        :param pulumi.Input[builtins.str] edge_security_policy: Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the
-               EdgeCacheService.
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] edge_ssl_certificates: URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService. Note
-               that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
+        :param pulumi.Input[builtins.str] edge_security_policy: Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] edge_ssl_certificates: URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService.
+               Note that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] effective_labels: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv4_addresses: The IPv4 addresses associated with this service. Addresses are static for the lifetime of the service.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv6_addresses: The IPv6 addresses associated with this service. Addresses are static for the lifetime of the service.
-        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Set of label tags associated with the EdgeCache resource. **Note**: This field is non-authoritative, and will only
-               manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
-               present on the resource.
-        :param pulumi.Input['EdgeCacheServiceLogConfigArgs'] log_config: Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to
-               Cloud Logging.
+        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Set of label tags associated with the EdgeCache resource.
+               **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+               Please refer to the field `effective_labels` for all of the labels present on the resource.
+        :param pulumi.Input['EdgeCacheServiceLogConfigArgs'] log_config: Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to Cloud Logging.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource; provided by the client when the resource is created.
                The name must be 1-64 characters long, and match the regular expression [a-zA-Z][a-zA-Z0-9_-]* which means the first character must be a letter,
                and all following characters must be a dash, underscore, letter or digit.
+        :param pulumi.Input[builtins.str] project: The ID of the project in which the resource belongs.
+               If it is not provided, the provider project is used.
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] pulumi_labels: The combination of labels configured directly on the resource
                and default labels configured on the provider.
-        :param pulumi.Input[builtins.bool] require_tls: Require TLS (HTTPS) for all clients connecting to this service. Clients who connect over HTTP (port 80) will receive a
-               HTTP 301 to the same URL over HTTPS (port 443). You must have at least one (1) edgeSslCertificate specified to enable
-               this.
+        :param pulumi.Input[builtins.bool] require_tls: Require TLS (HTTPS) for all clients connecting to this service.
+               Clients who connect over HTTP (port 80) will receive a HTTP 301 to the same URL over HTTPS (port 443).
+               You must have at least one (1) edgeSslCertificate specified to enable this.
         :param pulumi.Input['EdgeCacheServiceRoutingArgs'] routing: Defines how requests are routed, modified, cached and/or which origin content is filled from.
                Structure is documented below.
-        :param pulumi.Input[builtins.str] ssl_policy: URL of the SslPolicy resource that will be associated with the EdgeCacheService. If not set, the EdgeCacheService has no
-               SSL policy configured, and will default to the "COMPATIBLE" policy.
+        :param pulumi.Input[builtins.str] ssl_policy: URL of the SslPolicy resource that will be associated with the EdgeCacheService.
+               If not set, the EdgeCacheService has no SSL policy configured, and will default to the "COMPATIBLE" policy.
         """
         if description is not None:
             pulumi.set(__self__, "description", description)
@@ -343,10 +345,9 @@ class _EdgeCacheServiceState:
     @pulumi.getter(name="disableHttp2")
     def disable_http2(self) -> Optional[pulumi.Input[builtins.bool]]:
         """
-        Disables HTTP/2. HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use
-        and reduces connection setup overhead by sending multiple streams over the same connection. Some legacy HTTP clients may
-        have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from
-        being advertised and negotiated.
+        Disables HTTP/2.
+        HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use and reduces connection setup overhead by sending multiple streams over the same connection.
+        Some legacy HTTP clients may have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from being advertised and negotiated.
         """
         return pulumi.get(self, "disable_http2")
 
@@ -370,8 +371,7 @@ class _EdgeCacheServiceState:
     @pulumi.getter(name="edgeSecurityPolicy")
     def edge_security_policy(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the
-        EdgeCacheService.
+        Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.
         """
         return pulumi.get(self, "edge_security_policy")
 
@@ -383,8 +383,8 @@ class _EdgeCacheServiceState:
     @pulumi.getter(name="edgeSslCertificates")
     def edge_ssl_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
         """
-        URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService. Note
-        that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
+        URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService.
+        Note that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
         """
         return pulumi.get(self, "edge_ssl_certificates")
 
@@ -432,9 +432,9 @@ class _EdgeCacheServiceState:
     @pulumi.getter
     def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
         """
-        Set of label tags associated with the EdgeCache resource. **Note**: This field is non-authoritative, and will only
-        manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
-        present on the resource.
+        Set of label tags associated with the EdgeCache resource.
+        **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+        Please refer to the field `effective_labels` for all of the labels present on the resource.
         """
         return pulumi.get(self, "labels")
 
@@ -446,8 +446,8 @@ class _EdgeCacheServiceState:
     @pulumi.getter(name="logConfig")
     def log_config(self) -> Optional[pulumi.Input['EdgeCacheServiceLogConfigArgs']]:
         """
-        Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to
-        Cloud Logging.
+        Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to Cloud Logging.
+        Structure is documented below.
         """
         return pulumi.get(self, "log_config")
 
@@ -472,6 +472,10 @@ class _EdgeCacheServiceState:
     @property
     @pulumi.getter
     def project(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The ID of the project in which the resource belongs.
+        If it is not provided, the provider project is used.
+        """
         return pulumi.get(self, "project")
 
     @project.setter
@@ -495,9 +499,9 @@ class _EdgeCacheServiceState:
     @pulumi.getter(name="requireTls")
     def require_tls(self) -> Optional[pulumi.Input[builtins.bool]]:
         """
-        Require TLS (HTTPS) for all clients connecting to this service. Clients who connect over HTTP (port 80) will receive a
-        HTTP 301 to the same URL over HTTPS (port 443). You must have at least one (1) edgeSslCertificate specified to enable
-        this.
+        Require TLS (HTTPS) for all clients connecting to this service.
+        Clients who connect over HTTP (port 80) will receive a HTTP 301 to the same URL over HTTPS (port 443).
+        You must have at least one (1) edgeSslCertificate specified to enable this.
         """
         return pulumi.get(self, "require_tls")
 
@@ -522,8 +526,8 @@ class _EdgeCacheServiceState:
     @pulumi.getter(name="sslPolicy")
     def ssl_policy(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        URL of the SslPolicy resource that will be associated with the EdgeCacheService. If not set, the EdgeCacheService has no
-        SSL policy configured, and will default to the "COMPATIBLE" policy.
+        URL of the SslPolicy resource that will be associated with the EdgeCacheService.
+        If not set, the EdgeCacheService has no SSL policy configured, and will default to the "COMPATIBLE" policy.
         """
         return pulumi.get(self, "ssl_policy")
 
@@ -953,30 +957,30 @@ class EdgeCacheService(pulumi.CustomResource):
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[builtins.str] description: A human-readable description of the resource.
-        :param pulumi.Input[builtins.bool] disable_http2: Disables HTTP/2. HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use
-               and reduces connection setup overhead by sending multiple streams over the same connection. Some legacy HTTP clients may
-               have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from
-               being advertised and negotiated.
+        :param pulumi.Input[builtins.bool] disable_http2: Disables HTTP/2.
+               HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use and reduces connection setup overhead by sending multiple streams over the same connection.
+               Some legacy HTTP clients may have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from being advertised and negotiated.
         :param pulumi.Input[builtins.bool] disable_quic: HTTP/3 (IETF QUIC) and Google QUIC are enabled by default.
-        :param pulumi.Input[builtins.str] edge_security_policy: Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the
-               EdgeCacheService.
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] edge_ssl_certificates: URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService. Note
-               that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
-        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Set of label tags associated with the EdgeCache resource. **Note**: This field is non-authoritative, and will only
-               manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
-               present on the resource.
-        :param pulumi.Input[Union['EdgeCacheServiceLogConfigArgs', 'EdgeCacheServiceLogConfigArgsDict']] log_config: Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to
-               Cloud Logging.
+        :param pulumi.Input[builtins.str] edge_security_policy: Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] edge_ssl_certificates: URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService.
+               Note that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
+        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Set of label tags associated with the EdgeCache resource.
+               **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+               Please refer to the field `effective_labels` for all of the labels present on the resource.
+        :param pulumi.Input[Union['EdgeCacheServiceLogConfigArgs', 'EdgeCacheServiceLogConfigArgsDict']] log_config: Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to Cloud Logging.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource; provided by the client when the resource is created.
                The name must be 1-64 characters long, and match the regular expression [a-zA-Z][a-zA-Z0-9_-]* which means the first character must be a letter,
                and all following characters must be a dash, underscore, letter or digit.
-        :param pulumi.Input[builtins.bool] require_tls: Require TLS (HTTPS) for all clients connecting to this service. Clients who connect over HTTP (port 80) will receive a
-               HTTP 301 to the same URL over HTTPS (port 443). You must have at least one (1) edgeSslCertificate specified to enable
-               this.
+        :param pulumi.Input[builtins.str] project: The ID of the project in which the resource belongs.
+               If it is not provided, the provider project is used.
+        :param pulumi.Input[builtins.bool] require_tls: Require TLS (HTTPS) for all clients connecting to this service.
+               Clients who connect over HTTP (port 80) will receive a HTTP 301 to the same URL over HTTPS (port 443).
+               You must have at least one (1) edgeSslCertificate specified to enable this.
         :param pulumi.Input[Union['EdgeCacheServiceRoutingArgs', 'EdgeCacheServiceRoutingArgsDict']] routing: Defines how requests are routed, modified, cached and/or which origin content is filled from.
                Structure is documented below.
-        :param pulumi.Input[builtins.str] ssl_policy: URL of the SslPolicy resource that will be associated with the EdgeCacheService. If not set, the EdgeCacheService has no
-               SSL policy configured, and will default to the "COMPATIBLE" policy.
+        :param pulumi.Input[builtins.str] ssl_policy: URL of the SslPolicy resource that will be associated with the EdgeCacheService.
+               If not set, the EdgeCacheService has no SSL policy configured, and will default to the "COMPATIBLE" policy.
         """
         ...
     @overload
@@ -1473,35 +1477,35 @@ class EdgeCacheService(pulumi.CustomResource):
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[builtins.str] description: A human-readable description of the resource.
-        :param pulumi.Input[builtins.bool] disable_http2: Disables HTTP/2. HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use
-               and reduces connection setup overhead by sending multiple streams over the same connection. Some legacy HTTP clients may
-               have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from
-               being advertised and negotiated.
+        :param pulumi.Input[builtins.bool] disable_http2: Disables HTTP/2.
+               HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use and reduces connection setup overhead by sending multiple streams over the same connection.
+               Some legacy HTTP clients may have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from being advertised and negotiated.
         :param pulumi.Input[builtins.bool] disable_quic: HTTP/3 (IETF QUIC) and Google QUIC are enabled by default.
-        :param pulumi.Input[builtins.str] edge_security_policy: Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the
-               EdgeCacheService.
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] edge_ssl_certificates: URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService. Note
-               that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
+        :param pulumi.Input[builtins.str] edge_security_policy: Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] edge_ssl_certificates: URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService.
+               Note that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] effective_labels: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv4_addresses: The IPv4 addresses associated with this service. Addresses are static for the lifetime of the service.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv6_addresses: The IPv6 addresses associated with this service. Addresses are static for the lifetime of the service.
-        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Set of label tags associated with the EdgeCache resource. **Note**: This field is non-authoritative, and will only
-               manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
-               present on the resource.
-        :param pulumi.Input[Union['EdgeCacheServiceLogConfigArgs', 'EdgeCacheServiceLogConfigArgsDict']] log_config: Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to
-               Cloud Logging.
+        :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Set of label tags associated with the EdgeCache resource.
+               **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+               Please refer to the field `effective_labels` for all of the labels present on the resource.
+        :param pulumi.Input[Union['EdgeCacheServiceLogConfigArgs', 'EdgeCacheServiceLogConfigArgsDict']] log_config: Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to Cloud Logging.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource; provided by the client when the resource is created.
                The name must be 1-64 characters long, and match the regular expression [a-zA-Z][a-zA-Z0-9_-]* which means the first character must be a letter,
                and all following characters must be a dash, underscore, letter or digit.
+        :param pulumi.Input[builtins.str] project: The ID of the project in which the resource belongs.
+               If it is not provided, the provider project is used.
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] pulumi_labels: The combination of labels configured directly on the resource
                and default labels configured on the provider.
-        :param pulumi.Input[builtins.bool] require_tls: Require TLS (HTTPS) for all clients connecting to this service. Clients who connect over HTTP (port 80) will receive a
-               HTTP 301 to the same URL over HTTPS (port 443). You must have at least one (1) edgeSslCertificate specified to enable
-               this.
+        :param pulumi.Input[builtins.bool] require_tls: Require TLS (HTTPS) for all clients connecting to this service.
+               Clients who connect over HTTP (port 80) will receive a HTTP 301 to the same URL over HTTPS (port 443).
+               You must have at least one (1) edgeSslCertificate specified to enable this.
         :param pulumi.Input[Union['EdgeCacheServiceRoutingArgs', 'EdgeCacheServiceRoutingArgsDict']] routing: Defines how requests are routed, modified, cached and/or which origin content is filled from.
                Structure is documented below.
-        :param pulumi.Input[builtins.str] ssl_policy: URL of the SslPolicy resource that will be associated with the EdgeCacheService. If not set, the EdgeCacheService has no
-               SSL policy configured, and will default to the "COMPATIBLE" policy.
+        :param pulumi.Input[builtins.str] ssl_policy: URL of the SslPolicy resource that will be associated with the EdgeCacheService.
+               If not set, the EdgeCacheService has no SSL policy configured, and will default to the "COMPATIBLE" policy.
         """
         opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
 
@@ -1537,10 +1541,9 @@ class EdgeCacheService(pulumi.CustomResource):
     @pulumi.getter(name="disableHttp2")
     def disable_http2(self) -> pulumi.Output[Optional[builtins.bool]]:
         """
-        Disables HTTP/2. HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use
-        and reduces connection setup overhead by sending multiple streams over the same connection. Some legacy HTTP clients may
-        have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from
-        being advertised and negotiated.
+        Disables HTTP/2.
+        HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use and reduces connection setup overhead by sending multiple streams over the same connection.
+        Some legacy HTTP clients may have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from being advertised and negotiated.
         """
         return pulumi.get(self, "disable_http2")
 
@@ -1556,8 +1559,7 @@ class EdgeCacheService(pulumi.CustomResource):
     @pulumi.getter(name="edgeSecurityPolicy")
     def edge_security_policy(self) -> pulumi.Output[Optional[builtins.str]]:
         """
-        Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the
-        EdgeCacheService.
+        Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.
         """
         return pulumi.get(self, "edge_security_policy")
 
@@ -1565,8 +1567,8 @@ class EdgeCacheService(pulumi.CustomResource):
     @pulumi.getter(name="edgeSslCertificates")
     def edge_ssl_certificates(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
         """
-        URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService. Note
-        that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
+        URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService.
+        Note that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.
         """
         return pulumi.get(self, "edge_ssl_certificates")
 
@@ -1598,9 +1600,9 @@ class EdgeCacheService(pulumi.CustomResource):
     @pulumi.getter
     def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]:
         """
-        Set of label tags associated with the EdgeCache resource. **Note**: This field is non-authoritative, and will only
-        manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
-        present on the resource.
+        Set of label tags associated with the EdgeCache resource.
+        **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+        Please refer to the field `effective_labels` for all of the labels present on the resource.
         """
         return pulumi.get(self, "labels")
 
@@ -1608,8 +1610,8 @@ class EdgeCacheService(pulumi.CustomResource):
     @pulumi.getter(name="logConfig")
     def log_config(self) -> pulumi.Output[Optional['outputs.EdgeCacheServiceLogConfig']]:
         """
-        Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to
-        Cloud Logging.
+        Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to Cloud Logging.
+        Structure is documented below.
         """
         return pulumi.get(self, "log_config")
 
@@ -1626,6 +1628,10 @@ class EdgeCacheService(pulumi.CustomResource):
     @property
     @pulumi.getter
     def project(self) -> pulumi.Output[builtins.str]:
+        """
+        The ID of the project in which the resource belongs.
+        If it is not provided, the provider project is used.
+        """
         return pulumi.get(self, "project")
 
     @property
@@ -1641,9 +1647,9 @@ class EdgeCacheService(pulumi.CustomResource):
     @pulumi.getter(name="requireTls")
     def require_tls(self) -> pulumi.Output[builtins.bool]:
         """
-        Require TLS (HTTPS) for all clients connecting to this service. Clients who connect over HTTP (port 80) will receive a
-        HTTP 301 to the same URL over HTTPS (port 443). You must have at least one (1) edgeSslCertificate specified to enable
-        this.
+        Require TLS (HTTPS) for all clients connecting to this service.
+        Clients who connect over HTTP (port 80) will receive a HTTP 301 to the same URL over HTTPS (port 443).
+        You must have at least one (1) edgeSslCertificate specified to enable this.
         """
         return pulumi.get(self, "require_tls")
 
@@ -1660,8 +1666,8 @@ class EdgeCacheService(pulumi.CustomResource):
     @pulumi.getter(name="sslPolicy")
     def ssl_policy(self) -> pulumi.Output[Optional[builtins.str]]:
         """
-        URL of the SslPolicy resource that will be associated with the EdgeCacheService. If not set, the EdgeCacheService has no
-        SSL policy configured, and will default to the "COMPATIBLE" policy.
+        URL of the SslPolicy resource that will be associated with the EdgeCacheService.
+        If not set, the EdgeCacheService has no SSL policy configured, and will default to the "COMPATIBLE" policy.
         """
         return pulumi.get(self, "ssl_policy")