pulumi-gcp 6.68.0a1697867869__py3-none-any.whl → 6.68.0a1698199636__py3-none-any.whl

pulumi_gcp/compute/ssl_certificate.py

@@ -58,13 +58,23 @@ class SSLCertificateArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             certificate: pulumi.Input[str],
-             private_key: pulumi.Input[str],
+             certificate: Optional[pulumi.Input[str]] = None,
+             private_key: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
              name: Optional[pulumi.Input[str]] = None,
              name_prefix: Optional[pulumi.Input[str]] = None,
              project: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if certificate is None:
+            raise TypeError("Missing 'certificate' argument")
+        if private_key is None and 'privateKey' in kwargs:
+            private_key = kwargs['privateKey']
+        if private_key is None:
+            raise TypeError("Missing 'private_key' argument")
+        if name_prefix is None and 'namePrefix' in kwargs:
+            name_prefix = kwargs['namePrefix']
+
         _setter("certificate", certificate)
         _setter("private_key", private_key)
         if description is not None:
@@ -235,7 +245,21 @@ class _SSLCertificateState:
              private_key: Optional[pulumi.Input[str]] = None,
              project: Optional[pulumi.Input[str]] = None,
              self_link: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if certificate_id is None and 'certificateId' in kwargs:
+            certificate_id = kwargs['certificateId']
+        if creation_timestamp is None and 'creationTimestamp' in kwargs:
+            creation_timestamp = kwargs['creationTimestamp']
+        if expire_time is None and 'expireTime' in kwargs:
+            expire_time = kwargs['expireTime']
+        if name_prefix is None and 'namePrefix' in kwargs:
+            name_prefix = kwargs['namePrefix']
+        if private_key is None and 'privateKey' in kwargs:
+            private_key = kwargs['privateKey']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+
         if certificate is not None:
             _setter("certificate", certificate)
         if certificate_id is not None:
@@ -422,44 +446,6 @@ class SSLCertificate(pulumi.CustomResource):
         state as plain-text.
 
         ## Example Usage
-        ### Ssl Certificate Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default = gcp.compute.SSLCertificate("default",
-            name_prefix="my-certificate-",
-            description="a description",
-            private_key=(lambda path: open(path).read())("path/to/private.key"),
-            certificate=(lambda path: open(path).read())("path/to/certificate.crt"))
-        ```
-        ### Ssl Certificate Random Provider
-
-        ```python
-        import pulumi
-        import base64
-        import hashlib
-        import pulumi_gcp as gcp
-        import pulumi_random as random
-
-        def computeFilebase64sha256(path):
-        	fileData = open(path).read().encode()
-        	hashedData = hashlib.sha256(fileData.encode()).digest()
-        	return base64.b64encode(hashedData).decode()
-
-        # You may also want to control name generation explicitly:
-        default = gcp.compute.SSLCertificate("default",
-            private_key=(lambda path: open(path).read())("path/to/private.key"),
-            certificate=(lambda path: open(path).read())("path/to/certificate.crt"))
-        certificate = random.RandomId("certificate",
-            byte_length=4,
-            prefix="my-certificate-",
-            keepers={
-                "private_key": computeFilebase64sha256("path/to/private.key"),
-                "certificate": computeFilebase64sha256("path/to/certificate.crt"),
-            })
-        ```
 
         ## Import
 
@@ -524,44 +510,6 @@ class SSLCertificate(pulumi.CustomResource):
         state as plain-text.
 
         ## Example Usage
-        ### Ssl Certificate Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default = gcp.compute.SSLCertificate("default",
-            name_prefix="my-certificate-",
-            description="a description",
-            private_key=(lambda path: open(path).read())("path/to/private.key"),
-            certificate=(lambda path: open(path).read())("path/to/certificate.crt"))
-        ```
-        ### Ssl Certificate Random Provider
-
-        ```python
-        import pulumi
-        import base64
-        import hashlib
-        import pulumi_gcp as gcp
-        import pulumi_random as random
-
-        def computeFilebase64sha256(path):
-        	fileData = open(path).read().encode()
-        	hashedData = hashlib.sha256(fileData.encode()).digest()
-        	return base64.b64encode(hashedData).decode()
-
-        # You may also want to control name generation explicitly:
-        default = gcp.compute.SSLCertificate("default",
-            private_key=(lambda path: open(path).read())("path/to/private.key"),
-            certificate=(lambda path: open(path).read())("path/to/certificate.crt"))
-        certificate = random.RandomId("certificate",
-            byte_length=4,
-            prefix="my-certificate-",
-            keepers={
-                "private_key": computeFilebase64sha256("path/to/private.key"),
-                "certificate": computeFilebase64sha256("path/to/certificate.crt"),
-            })
-        ```
 
         ## Import
 

pulumi_gcp/compute/ssl_policy.py

@@ -76,7 +76,13 @@ class SSLPolicyArgs:
              name: Optional[pulumi.Input[str]] = None,
              profile: Optional[pulumi.Input[str]] = None,
              project: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if custom_features is None and 'customFeatures' in kwargs:
+            custom_features = kwargs['customFeatures']
+        if min_tls_version is None and 'minTlsVersion' in kwargs:
+            min_tls_version = kwargs['minTlsVersion']
+
         if custom_features is not None:
             _setter("custom_features", custom_features)
         if description is not None:
@@ -274,7 +280,19 @@ class _SSLPolicyState:
              profile: Optional[pulumi.Input[str]] = None,
              project: Optional[pulumi.Input[str]] = None,
              self_link: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if creation_timestamp is None and 'creationTimestamp' in kwargs:
+            creation_timestamp = kwargs['creationTimestamp']
+        if custom_features is None and 'customFeatures' in kwargs:
+            custom_features = kwargs['customFeatures']
+        if enabled_features is None and 'enabledFeatures' in kwargs:
+            enabled_features = kwargs['enabledFeatures']
+        if min_tls_version is None and 'minTlsVersion' in kwargs:
+            min_tls_version = kwargs['minTlsVersion']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+
         if creation_timestamp is not None:
             _setter("creation_timestamp", creation_timestamp)
         if custom_features is not None:
@@ -470,24 +488,6 @@ class SSLPolicy(pulumi.CustomResource):
             * [Using SSL Policies](https://cloud.google.com/compute/docs/load-balancing/ssl-policies)
 
         ## Example Usage
-        ### Ssl Policy Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        prod_ssl_policy = gcp.compute.SSLPolicy("prod-ssl-policy", profile="MODERN")
-        nonprod_ssl_policy = gcp.compute.SSLPolicy("nonprod-ssl-policy",
-            min_tls_version="TLS_1_2",
-            profile="MODERN")
-        custom_ssl_policy = gcp.compute.SSLPolicy("custom-ssl-policy",
-            custom_features=[
-                "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
-                "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
-            ],
-            min_tls_version="TLS_1_2",
-            profile="CUSTOM")
-        ```
 
         ## Import
 
@@ -560,24 +560,6 @@ class SSLPolicy(pulumi.CustomResource):
             * [Using SSL Policies](https://cloud.google.com/compute/docs/load-balancing/ssl-policies)
 
         ## Example Usage
-        ### Ssl Policy Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        prod_ssl_policy = gcp.compute.SSLPolicy("prod-ssl-policy", profile="MODERN")
-        nonprod_ssl_policy = gcp.compute.SSLPolicy("nonprod-ssl-policy",
-            min_tls_version="TLS_1_2",
-            profile="MODERN")
-        custom_ssl_policy = gcp.compute.SSLPolicy("custom-ssl-policy",
-            custom_features=[
-                "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
-                "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
-            ],
-            min_tls_version="TLS_1_2",
-            profile="CUSTOM")
-        ```
 
         ## Import
 

pulumi_gcp/compute/subnetwork.py

@@ -107,8 +107,8 @@ class SubnetworkArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             ip_cidr_range: pulumi.Input[str],
-             network: pulumi.Input[str],
+             ip_cidr_range: Optional[pulumi.Input[str]] = None,
+             network: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
              ipv6_access_type: Optional[pulumi.Input[str]] = None,
              log_config: Optional[pulumi.Input['SubnetworkLogConfigArgs']] = None,
@@ -121,7 +121,27 @@ class SubnetworkArgs:
              role: Optional[pulumi.Input[str]] = None,
              secondary_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['SubnetworkSecondaryIpRangeArgs']]]] = None,
              stack_type: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if ip_cidr_range is None and 'ipCidrRange' in kwargs:
+            ip_cidr_range = kwargs['ipCidrRange']
+        if ip_cidr_range is None:
+            raise TypeError("Missing 'ip_cidr_range' argument")
+        if network is None:
+            raise TypeError("Missing 'network' argument")
+        if ipv6_access_type is None and 'ipv6AccessType' in kwargs:
+            ipv6_access_type = kwargs['ipv6AccessType']
+        if log_config is None and 'logConfig' in kwargs:
+            log_config = kwargs['logConfig']
+        if private_ip_google_access is None and 'privateIpGoogleAccess' in kwargs:
+            private_ip_google_access = kwargs['privateIpGoogleAccess']
+        if private_ipv6_google_access is None and 'privateIpv6GoogleAccess' in kwargs:
+            private_ipv6_google_access = kwargs['privateIpv6GoogleAccess']
+        if secondary_ip_ranges is None and 'secondaryIpRanges' in kwargs:
+            secondary_ip_ranges = kwargs['secondaryIpRanges']
+        if stack_type is None and 'stackType' in kwargs:
+            stack_type = kwargs['stackType']
+
         _setter("ip_cidr_range", ip_cidr_range)
         _setter("network", network)
         if description is not None:
@@ -495,7 +515,35 @@ class _SubnetworkState:
              secondary_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['SubnetworkSecondaryIpRangeArgs']]]] = None,
              self_link: Optional[pulumi.Input[str]] = None,
              stack_type: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if creation_timestamp is None and 'creationTimestamp' in kwargs:
+            creation_timestamp = kwargs['creationTimestamp']
+        if external_ipv6_prefix is None and 'externalIpv6Prefix' in kwargs:
+            external_ipv6_prefix = kwargs['externalIpv6Prefix']
+        if gateway_address is None and 'gatewayAddress' in kwargs:
+            gateway_address = kwargs['gatewayAddress']
+        if internal_ipv6_prefix is None and 'internalIpv6Prefix' in kwargs:
+            internal_ipv6_prefix = kwargs['internalIpv6Prefix']
+        if ip_cidr_range is None and 'ipCidrRange' in kwargs:
+            ip_cidr_range = kwargs['ipCidrRange']
+        if ipv6_access_type is None and 'ipv6AccessType' in kwargs:
+            ipv6_access_type = kwargs['ipv6AccessType']
+        if ipv6_cidr_range is None and 'ipv6CidrRange' in kwargs:
+            ipv6_cidr_range = kwargs['ipv6CidrRange']
+        if log_config is None and 'logConfig' in kwargs:
+            log_config = kwargs['logConfig']
+        if private_ip_google_access is None and 'privateIpGoogleAccess' in kwargs:
+            private_ip_google_access = kwargs['privateIpGoogleAccess']
+        if private_ipv6_google_access is None and 'privateIpv6GoogleAccess' in kwargs:
+            private_ipv6_google_access = kwargs['privateIpv6GoogleAccess']
+        if secondary_ip_ranges is None and 'secondaryIpRanges' in kwargs:
+            secondary_ip_ranges = kwargs['secondaryIpRanges']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+        if stack_type is None and 'stackType' in kwargs:
+            stack_type = kwargs['stackType']
+
         if creation_timestamp is not None:
             _setter("creation_timestamp", creation_timestamp)
         if description is not None:
@@ -891,85 +939,6 @@ class Subnetwork(pulumi.CustomResource):
             * [Cloud Networking](https://cloud.google.com/vpc/docs/using-vpc)
 
         ## Example Usage
-        ### Subnetwork Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        custom_test = gcp.compute.Network("custom-test", auto_create_subnetworks=False)
-        network_with_private_secondary_ip_ranges = gcp.compute.Subnetwork("network-with-private-secondary-ip-ranges",
-            ip_cidr_range="10.2.0.0/16",
-            region="us-central1",
-            network=custom_test.id,
-            secondary_ip_ranges=[gcp.compute.SubnetworkSecondaryIpRangeArgs(
-                range_name="tf-test-secondary-range-update1",
-                ip_cidr_range="192.168.10.0/24",
-            )])
-        ```
-        ### Subnetwork Logging Config
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        custom_test = gcp.compute.Network("custom-test", auto_create_subnetworks=False)
-        subnet_with_logging = gcp.compute.Subnetwork("subnet-with-logging",
-            ip_cidr_range="10.2.0.0/16",
-            region="us-central1",
-            network=custom_test.id,
-            log_config=gcp.compute.SubnetworkLogConfigArgs(
-                aggregation_interval="INTERVAL_10_MIN",
-                flow_sampling=0.5,
-                metadata="INCLUDE_ALL_METADATA",
-            ))
-        ```
-        ### Subnetwork Internal L7lb
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        custom_test = gcp.compute.Network("custom-test", auto_create_subnetworks=False,
-        opts=pulumi.ResourceOptions(provider=google_beta))
-        network_for_l7lb = gcp.compute.Subnetwork("network-for-l7lb",
-            ip_cidr_range="10.0.0.0/22",
-            region="us-central1",
-            purpose="REGIONAL_MANAGED_PROXY",
-            role="ACTIVE",
-            network=custom_test.id,
-            opts=pulumi.ResourceOptions(provider=google_beta))
-        ```
-        ### Subnetwork Ipv6
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        custom_test = gcp.compute.Network("custom-test", auto_create_subnetworks=False)
-        subnetwork_ipv6 = gcp.compute.Subnetwork("subnetwork-ipv6",
-            ip_cidr_range="10.0.0.0/22",
-            region="us-west2",
-            stack_type="IPV4_IPV6",
-            ipv6_access_type="EXTERNAL",
-            network=custom_test.id)
-        ```
-        ### Subnetwork Internal Ipv6
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        custom_test = gcp.compute.Network("custom-test",
-            auto_create_subnetworks=False,
-            enable_ula_internal_ipv6=True)
-        subnetwork_internal_ipv6 = gcp.compute.Subnetwork("subnetwork-internal-ipv6",
-            ip_cidr_range="10.0.0.0/22",
-            region="us-west2",
-            stack_type="IPV4_IPV6",
-            ipv6_access_type="INTERNAL",
-            network=custom_test.id)
-        ```
 
         ## Import
 
@@ -1086,85 +1055,6 @@ class Subnetwork(pulumi.CustomResource):
             * [Cloud Networking](https://cloud.google.com/vpc/docs/using-vpc)
 
         ## Example Usage
-        ### Subnetwork Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        custom_test = gcp.compute.Network("custom-test", auto_create_subnetworks=False)
-        network_with_private_secondary_ip_ranges = gcp.compute.Subnetwork("network-with-private-secondary-ip-ranges",
-            ip_cidr_range="10.2.0.0/16",
-            region="us-central1",
-            network=custom_test.id,
-            secondary_ip_ranges=[gcp.compute.SubnetworkSecondaryIpRangeArgs(
-                range_name="tf-test-secondary-range-update1",
-                ip_cidr_range="192.168.10.0/24",
-            )])
-        ```
-        ### Subnetwork Logging Config
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        custom_test = gcp.compute.Network("custom-test", auto_create_subnetworks=False)
-        subnet_with_logging = gcp.compute.Subnetwork("subnet-with-logging",
-            ip_cidr_range="10.2.0.0/16",
-            region="us-central1",
-            network=custom_test.id,
-            log_config=gcp.compute.SubnetworkLogConfigArgs(
-                aggregation_interval="INTERVAL_10_MIN",
-                flow_sampling=0.5,
-                metadata="INCLUDE_ALL_METADATA",
-            ))
-        ```
-        ### Subnetwork Internal L7lb
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        custom_test = gcp.compute.Network("custom-test", auto_create_subnetworks=False,
-        opts=pulumi.ResourceOptions(provider=google_beta))
-        network_for_l7lb = gcp.compute.Subnetwork("network-for-l7lb",
-            ip_cidr_range="10.0.0.0/22",
-            region="us-central1",
-            purpose="REGIONAL_MANAGED_PROXY",
-            role="ACTIVE",
-            network=custom_test.id,
-            opts=pulumi.ResourceOptions(provider=google_beta))
-        ```
-        ### Subnetwork Ipv6
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        custom_test = gcp.compute.Network("custom-test", auto_create_subnetworks=False)
-        subnetwork_ipv6 = gcp.compute.Subnetwork("subnetwork-ipv6",
-            ip_cidr_range="10.0.0.0/22",
-            region="us-west2",
-            stack_type="IPV4_IPV6",
-            ipv6_access_type="EXTERNAL",
-            network=custom_test.id)
-        ```
-        ### Subnetwork Internal Ipv6
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        custom_test = gcp.compute.Network("custom-test",
-            auto_create_subnetworks=False,
-            enable_ula_internal_ipv6=True)
-        subnetwork_internal_ipv6 = gcp.compute.Subnetwork("subnetwork-internal-ipv6",
-            ip_cidr_range="10.0.0.0/22",
-            region="us-west2",
-            stack_type="IPV4_IPV6",
-            ipv6_access_type="INTERNAL",
-            network=custom_test.id)
-        ```
 
         ## Import
 
@@ -1233,11 +1123,7 @@ class Subnetwork(pulumi.CustomResource):
                 raise TypeError("Missing required property 'ip_cidr_range'")
             __props__.__dict__["ip_cidr_range"] = ip_cidr_range
             __props__.__dict__["ipv6_access_type"] = ipv6_access_type
-            if log_config is not None and not isinstance(log_config, SubnetworkLogConfigArgs):
-                log_config = log_config or {}
-                def _setter(key, value):
-                    log_config[key] = value
-                SubnetworkLogConfigArgs._configure(_setter, **log_config)
+            log_config = _utilities.configure(log_config, SubnetworkLogConfigArgs, True)
             __props__.__dict__["log_config"] = log_config
             __props__.__dict__["name"] = name
             if network is None and not opts.urn: