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

pulumi_gcp/compute/route.py

@@ -104,8 +104,8 @@ class RouteArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             dest_range: pulumi.Input[str],
-             network: pulumi.Input[str],
+             dest_range: Optional[pulumi.Input[str]] = None,
+             network: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
              name: Optional[pulumi.Input[str]] = None,
              next_hop_gateway: Optional[pulumi.Input[str]] = None,
@@ -117,7 +117,27 @@ class RouteArgs:
              priority: Optional[pulumi.Input[int]] = None,
              project: Optional[pulumi.Input[str]] = None,
              tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if dest_range is None and 'destRange' in kwargs:
+            dest_range = kwargs['destRange']
+        if dest_range is None:
+            raise TypeError("Missing 'dest_range' argument")
+        if network is None:
+            raise TypeError("Missing 'network' argument")
+        if next_hop_gateway is None and 'nextHopGateway' in kwargs:
+            next_hop_gateway = kwargs['nextHopGateway']
+        if next_hop_ilb is None and 'nextHopIlb' in kwargs:
+            next_hop_ilb = kwargs['nextHopIlb']
+        if next_hop_instance is None and 'nextHopInstance' in kwargs:
+            next_hop_instance = kwargs['nextHopInstance']
+        if next_hop_instance_zone is None and 'nextHopInstanceZone' in kwargs:
+            next_hop_instance_zone = kwargs['nextHopInstanceZone']
+        if next_hop_ip is None and 'nextHopIp' in kwargs:
+            next_hop_ip = kwargs['nextHopIp']
+        if next_hop_vpn_tunnel is None and 'nextHopVpnTunnel' in kwargs:
+            next_hop_vpn_tunnel = kwargs['nextHopVpnTunnel']
+
         _setter("dest_range", dest_range)
         _setter("network", network)
         if description is not None:
@@ -456,7 +476,27 @@ class _RouteState:
              project: Optional[pulumi.Input[str]] = None,
              self_link: Optional[pulumi.Input[str]] = None,
              tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if dest_range is None and 'destRange' in kwargs:
+            dest_range = kwargs['destRange']
+        if next_hop_gateway is None and 'nextHopGateway' in kwargs:
+            next_hop_gateway = kwargs['nextHopGateway']
+        if next_hop_ilb is None and 'nextHopIlb' in kwargs:
+            next_hop_ilb = kwargs['nextHopIlb']
+        if next_hop_instance is None and 'nextHopInstance' in kwargs:
+            next_hop_instance = kwargs['nextHopInstance']
+        if next_hop_instance_zone is None and 'nextHopInstanceZone' in kwargs:
+            next_hop_instance_zone = kwargs['nextHopInstanceZone']
+        if next_hop_ip is None and 'nextHopIp' in kwargs:
+            next_hop_ip = kwargs['nextHopIp']
+        if next_hop_network is None and 'nextHopNetwork' in kwargs:
+            next_hop_network = kwargs['nextHopNetwork']
+        if next_hop_vpn_tunnel is None and 'nextHopVpnTunnel' in kwargs:
+            next_hop_vpn_tunnel = kwargs['nextHopVpnTunnel']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+
         if description is not None:
             _setter("description", description)
         if dest_range is not None:
@@ -761,19 +801,6 @@ class Route(pulumi.CustomResource):
             * [Using Routes](https://cloud.google.com/vpc/docs/using-routes)
 
         ## Example Usage
-        ### Route Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default_network = gcp.compute.Network("defaultNetwork")
-        default_route = gcp.compute.Route("defaultRoute",
-            dest_range="15.0.0.0/24",
-            network=default_network.name,
-            next_hop_ip="10.132.1.5",
-            priority=100)
-        ```
 
         ## Import
 
@@ -886,19 +913,6 @@ class Route(pulumi.CustomResource):
             * [Using Routes](https://cloud.google.com/vpc/docs/using-routes)
 
         ## Example Usage
-        ### Route Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default_network = gcp.compute.Network("defaultNetwork")
-        default_route = gcp.compute.Route("defaultRoute",
-            dest_range="15.0.0.0/24",
-            network=default_network.name,
-            next_hop_ip="10.132.1.5",
-            priority=100)
-        ```
 
         ## Import
 

pulumi_gcp/compute/router.py

@@ -57,14 +57,20 @@ class RouterArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             network: pulumi.Input[str],
+             network: Optional[pulumi.Input[str]] = None,
              bgp: Optional[pulumi.Input['RouterBgpArgs']] = None,
              description: Optional[pulumi.Input[str]] = None,
              encrypted_interconnect_router: Optional[pulumi.Input[bool]] = None,
              name: Optional[pulumi.Input[str]] = None,
              project: Optional[pulumi.Input[str]] = None,
              region: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if network is None:
+            raise TypeError("Missing 'network' argument")
+        if encrypted_interconnect_router is None and 'encryptedInterconnectRouter' in kwargs:
+            encrypted_interconnect_router = kwargs['encryptedInterconnectRouter']
+
         _setter("network", network)
         if bgp is not None:
             _setter("bgp", bgp)
@@ -234,7 +240,15 @@ class _RouterState:
              project: Optional[pulumi.Input[str]] = None,
              region: 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 encrypted_interconnect_router is None and 'encryptedInterconnectRouter' in kwargs:
+            encrypted_interconnect_router = kwargs['encryptedInterconnectRouter']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+
         if bgp is not None:
             _setter("bgp", bgp)
         if creation_timestamp is not None:
@@ -397,43 +411,6 @@ class Router(pulumi.CustomResource):
             * [Google Cloud Router](https://cloud.google.com/router/docs/)
 
         ## Example Usage
-        ### Router Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        foobar_network = gcp.compute.Network("foobarNetwork", auto_create_subnetworks=False)
-        foobar_router = gcp.compute.Router("foobarRouter",
-            network=foobar_network.name,
-            bgp=gcp.compute.RouterBgpArgs(
-                asn=64514,
-                advertise_mode="CUSTOM",
-                advertised_groups=["ALL_SUBNETS"],
-                advertised_ip_ranges=[
-                    gcp.compute.RouterBgpAdvertisedIpRangeArgs(
-                        range="1.2.3.4",
-                    ),
-                    gcp.compute.RouterBgpAdvertisedIpRangeArgs(
-                        range="6.7.0.0/16",
-                    ),
-                ],
-            ))
-        ```
-        ### Compute Router Encrypted Interconnect
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        network = gcp.compute.Network("network", auto_create_subnetworks=False)
-        encrypted_interconnect_router = gcp.compute.Router("encrypted-interconnect-router",
-            network=network.name,
-            encrypted_interconnect_router=True,
-            bgp=gcp.compute.RouterBgpArgs(
-                asn=64514,
-            ))
-        ```
 
         ## Import
 
@@ -492,43 +469,6 @@ class Router(pulumi.CustomResource):
             * [Google Cloud Router](https://cloud.google.com/router/docs/)
 
         ## Example Usage
-        ### Router Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        foobar_network = gcp.compute.Network("foobarNetwork", auto_create_subnetworks=False)
-        foobar_router = gcp.compute.Router("foobarRouter",
-            network=foobar_network.name,
-            bgp=gcp.compute.RouterBgpArgs(
-                asn=64514,
-                advertise_mode="CUSTOM",
-                advertised_groups=["ALL_SUBNETS"],
-                advertised_ip_ranges=[
-                    gcp.compute.RouterBgpAdvertisedIpRangeArgs(
-                        range="1.2.3.4",
-                    ),
-                    gcp.compute.RouterBgpAdvertisedIpRangeArgs(
-                        range="6.7.0.0/16",
-                    ),
-                ],
-            ))
-        ```
-        ### Compute Router Encrypted Interconnect
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        network = gcp.compute.Network("network", auto_create_subnetworks=False)
-        encrypted_interconnect_router = gcp.compute.Router("encrypted-interconnect-router",
-            network=network.name,
-            encrypted_interconnect_router=True,
-            bgp=gcp.compute.RouterBgpArgs(
-                asn=64514,
-            ))
-        ```
 
         ## Import
 
@@ -585,11 +525,7 @@ class Router(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = RouterArgs.__new__(RouterArgs)
 
-            if bgp is not None and not isinstance(bgp, RouterBgpArgs):
-                bgp = bgp or {}
-                def _setter(key, value):
-                    bgp[key] = value
-                RouterBgpArgs._configure(_setter, **bgp)
+            bgp = _utilities.configure(bgp, RouterBgpArgs, True)
             __props__.__dict__["bgp"] = bgp
             __props__.__dict__["description"] = description
             __props__.__dict__["encrypted_interconnect_router"] = encrypted_interconnect_router

pulumi_gcp/compute/router_interface.py

@@ -69,7 +69,7 @@ class RouterInterfaceArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             router: pulumi.Input[str],
+             router: Optional[pulumi.Input[str]] = None,
              interconnect_attachment: Optional[pulumi.Input[str]] = None,
              ip_range: Optional[pulumi.Input[str]] = None,
              name: Optional[pulumi.Input[str]] = None,
@@ -79,7 +79,21 @@ class RouterInterfaceArgs:
              region: Optional[pulumi.Input[str]] = None,
              subnetwork: Optional[pulumi.Input[str]] = None,
              vpn_tunnel: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if router is None:
+            raise TypeError("Missing 'router' argument")
+        if interconnect_attachment is None and 'interconnectAttachment' in kwargs:
+            interconnect_attachment = kwargs['interconnectAttachment']
+        if ip_range is None and 'ipRange' in kwargs:
+            ip_range = kwargs['ipRange']
+        if private_ip_address is None and 'privateIpAddress' in kwargs:
+            private_ip_address = kwargs['privateIpAddress']
+        if redundant_interface is None and 'redundantInterface' in kwargs:
+            redundant_interface = kwargs['redundantInterface']
+        if vpn_tunnel is None and 'vpnTunnel' in kwargs:
+            vpn_tunnel = kwargs['vpnTunnel']
+
         _setter("router", router)
         if interconnect_attachment is not None:
             _setter("interconnect_attachment", interconnect_attachment)
@@ -305,7 +319,19 @@ class _RouterInterfaceState:
              router: Optional[pulumi.Input[str]] = None,
              subnetwork: Optional[pulumi.Input[str]] = None,
              vpn_tunnel: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if interconnect_attachment is None and 'interconnectAttachment' in kwargs:
+            interconnect_attachment = kwargs['interconnectAttachment']
+        if ip_range is None and 'ipRange' in kwargs:
+            ip_range = kwargs['ipRange']
+        if private_ip_address is None and 'privateIpAddress' in kwargs:
+            private_ip_address = kwargs['privateIpAddress']
+        if redundant_interface is None and 'redundantInterface' in kwargs:
+            redundant_interface = kwargs['redundantInterface']
+        if vpn_tunnel is None and 'vpnTunnel' in kwargs:
+            vpn_tunnel = kwargs['vpnTunnel']
+
         if interconnect_attachment is not None:
             _setter("interconnect_attachment", interconnect_attachment)
         if ip_range is not None:
@@ -486,19 +512,6 @@ class RouterInterface(pulumi.CustomResource):
         and
         [API](https://cloud.google.com/compute/docs/reference/latest/routers).
 
-        ## Example Usage
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        foobar = gcp.compute.RouterInterface("foobar",
-            ip_range="169.254.1.1/30",
-            region="us-central1",
-            router="router-1",
-            vpn_tunnel="tunnel-1")
-        ```
-
         ## Import
 
         Router interfaces can be imported using the `project` (optional), `region`, `router`, and `name`, e.g.
@@ -552,19 +565,6 @@ class RouterInterface(pulumi.CustomResource):
         and
         [API](https://cloud.google.com/compute/docs/reference/latest/routers).
 
-        ## Example Usage
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        foobar = gcp.compute.RouterInterface("foobar",
-            ip_range="169.254.1.1/30",
-            region="us-central1",
-            router="router-1",
-            vpn_tunnel="tunnel-1")
-        ```
-
         ## Import
 
         Router interfaces can be imported using the `project` (optional), `region`, `router`, and `name`, e.g.

pulumi_gcp/compute/router_nat.py

@@ -119,9 +119,9 @@ class RouterNatArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             nat_ip_allocate_option: pulumi.Input[str],
-             router: pulumi.Input[str],
-             source_subnetwork_ip_ranges_to_nat: pulumi.Input[str],
+             nat_ip_allocate_option: Optional[pulumi.Input[str]] = None,
+             router: Optional[pulumi.Input[str]] = None,
+             source_subnetwork_ip_ranges_to_nat: Optional[pulumi.Input[str]] = None,
              drain_nat_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              enable_dynamic_port_allocation: Optional[pulumi.Input[bool]] = None,
              enable_endpoint_independent_mapping: Optional[pulumi.Input[bool]] = None,
@@ -139,7 +139,43 @@ class RouterNatArgs:
              tcp_time_wait_timeout_sec: Optional[pulumi.Input[int]] = None,
              tcp_transitory_idle_timeout_sec: Optional[pulumi.Input[int]] = None,
              udp_idle_timeout_sec: Optional[pulumi.Input[int]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if nat_ip_allocate_option is None and 'natIpAllocateOption' in kwargs:
+            nat_ip_allocate_option = kwargs['natIpAllocateOption']
+        if nat_ip_allocate_option is None:
+            raise TypeError("Missing 'nat_ip_allocate_option' argument")
+        if router is None:
+            raise TypeError("Missing 'router' argument")
+        if source_subnetwork_ip_ranges_to_nat is None and 'sourceSubnetworkIpRangesToNat' in kwargs:
+            source_subnetwork_ip_ranges_to_nat = kwargs['sourceSubnetworkIpRangesToNat']
+        if source_subnetwork_ip_ranges_to_nat is None:
+            raise TypeError("Missing 'source_subnetwork_ip_ranges_to_nat' argument")
+        if drain_nat_ips is None and 'drainNatIps' in kwargs:
+            drain_nat_ips = kwargs['drainNatIps']
+        if enable_dynamic_port_allocation is None and 'enableDynamicPortAllocation' in kwargs:
+            enable_dynamic_port_allocation = kwargs['enableDynamicPortAllocation']
+        if enable_endpoint_independent_mapping is None and 'enableEndpointIndependentMapping' in kwargs:
+            enable_endpoint_independent_mapping = kwargs['enableEndpointIndependentMapping']
+        if icmp_idle_timeout_sec is None and 'icmpIdleTimeoutSec' in kwargs:
+            icmp_idle_timeout_sec = kwargs['icmpIdleTimeoutSec']
+        if log_config is None and 'logConfig' in kwargs:
+            log_config = kwargs['logConfig']
+        if max_ports_per_vm is None and 'maxPortsPerVm' in kwargs:
+            max_ports_per_vm = kwargs['maxPortsPerVm']
+        if min_ports_per_vm is None and 'minPortsPerVm' in kwargs:
+            min_ports_per_vm = kwargs['minPortsPerVm']
+        if nat_ips is None and 'natIps' in kwargs:
+            nat_ips = kwargs['natIps']
+        if tcp_established_idle_timeout_sec is None and 'tcpEstablishedIdleTimeoutSec' in kwargs:
+            tcp_established_idle_timeout_sec = kwargs['tcpEstablishedIdleTimeoutSec']
+        if tcp_time_wait_timeout_sec is None and 'tcpTimeWaitTimeoutSec' in kwargs:
+            tcp_time_wait_timeout_sec = kwargs['tcpTimeWaitTimeoutSec']
+        if tcp_transitory_idle_timeout_sec is None and 'tcpTransitoryIdleTimeoutSec' in kwargs:
+            tcp_transitory_idle_timeout_sec = kwargs['tcpTransitoryIdleTimeoutSec']
+        if udp_idle_timeout_sec is None and 'udpIdleTimeoutSec' in kwargs:
+            udp_idle_timeout_sec = kwargs['udpIdleTimeoutSec']
+
         _setter("nat_ip_allocate_option", nat_ip_allocate_option)
         _setter("router", router)
         _setter("source_subnetwork_ip_ranges_to_nat", source_subnetwork_ip_ranges_to_nat)
@@ -579,7 +615,37 @@ class _RouterNatState:
              tcp_time_wait_timeout_sec: Optional[pulumi.Input[int]] = None,
              tcp_transitory_idle_timeout_sec: Optional[pulumi.Input[int]] = None,
              udp_idle_timeout_sec: Optional[pulumi.Input[int]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if drain_nat_ips is None and 'drainNatIps' in kwargs:
+            drain_nat_ips = kwargs['drainNatIps']
+        if enable_dynamic_port_allocation is None and 'enableDynamicPortAllocation' in kwargs:
+            enable_dynamic_port_allocation = kwargs['enableDynamicPortAllocation']
+        if enable_endpoint_independent_mapping is None and 'enableEndpointIndependentMapping' in kwargs:
+            enable_endpoint_independent_mapping = kwargs['enableEndpointIndependentMapping']
+        if icmp_idle_timeout_sec is None and 'icmpIdleTimeoutSec' in kwargs:
+            icmp_idle_timeout_sec = kwargs['icmpIdleTimeoutSec']
+        if log_config is None and 'logConfig' in kwargs:
+            log_config = kwargs['logConfig']
+        if max_ports_per_vm is None and 'maxPortsPerVm' in kwargs:
+            max_ports_per_vm = kwargs['maxPortsPerVm']
+        if min_ports_per_vm is None and 'minPortsPerVm' in kwargs:
+            min_ports_per_vm = kwargs['minPortsPerVm']
+        if nat_ip_allocate_option is None and 'natIpAllocateOption' in kwargs:
+            nat_ip_allocate_option = kwargs['natIpAllocateOption']
+        if nat_ips is None and 'natIps' in kwargs:
+            nat_ips = kwargs['natIps']
+        if source_subnetwork_ip_ranges_to_nat is None and 'sourceSubnetworkIpRangesToNat' in kwargs:
+            source_subnetwork_ip_ranges_to_nat = kwargs['sourceSubnetworkIpRangesToNat']
+        if tcp_established_idle_timeout_sec is None and 'tcpEstablishedIdleTimeoutSec' in kwargs:
+            tcp_established_idle_timeout_sec = kwargs['tcpEstablishedIdleTimeoutSec']
+        if tcp_time_wait_timeout_sec is None and 'tcpTimeWaitTimeoutSec' in kwargs:
+            tcp_time_wait_timeout_sec = kwargs['tcpTimeWaitTimeoutSec']
+        if tcp_transitory_idle_timeout_sec is None and 'tcpTransitoryIdleTimeoutSec' in kwargs:
+            tcp_transitory_idle_timeout_sec = kwargs['tcpTransitoryIdleTimeoutSec']
+        if udp_idle_timeout_sec is None and 'udpIdleTimeoutSec' in kwargs:
+            udp_idle_timeout_sec = kwargs['udpIdleTimeoutSec']
+
         if drain_nat_ips is not None:
             _setter("drain_nat_ips", drain_nat_ips)
         if enable_dynamic_port_allocation is not None:
@@ -932,101 +998,6 @@ class RouterNat(pulumi.CustomResource):
             * [Google Cloud Router](https://cloud.google.com/router/docs/)
 
         ## Example Usage
-        ### Router Nat Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        net = gcp.compute.Network("net")
-        subnet = gcp.compute.Subnetwork("subnet",
-            network=net.id,
-            ip_cidr_range="10.0.0.0/16",
-            region="us-central1")
-        router = gcp.compute.Router("router",
-            region=subnet.region,
-            network=net.id,
-            bgp=gcp.compute.RouterBgpArgs(
-                asn=64514,
-            ))
-        nat = gcp.compute.RouterNat("nat",
-            router=router.name,
-            region=router.region,
-            nat_ip_allocate_option="AUTO_ONLY",
-            source_subnetwork_ip_ranges_to_nat="ALL_SUBNETWORKS_ALL_IP_RANGES",
-            log_config=gcp.compute.RouterNatLogConfigArgs(
-                enable=True,
-                filter="ERRORS_ONLY",
-            ))
-        ```
-        ### Router Nat Manual Ips
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        net = gcp.compute.Network("net")
-        subnet = gcp.compute.Subnetwork("subnet",
-            network=net.id,
-            ip_cidr_range="10.0.0.0/16",
-            region="us-central1")
-        router = gcp.compute.Router("router",
-            region=subnet.region,
-            network=net.id)
-        address = []
-        for range in [{"value": i} for i in range(0, 2)]:
-            address.append(gcp.compute.Address(f"address-{range['value']}", region=subnet.region))
-        nat_manual = gcp.compute.RouterNat("natManual",
-            router=router.name,
-            region=router.region,
-            nat_ip_allocate_option="MANUAL_ONLY",
-            nat_ips=[__item.self_link for __item in address],
-            source_subnetwork_ip_ranges_to_nat="LIST_OF_SUBNETWORKS",
-            subnetworks=[gcp.compute.RouterNatSubnetworkArgs(
-                name=subnet.id,
-                source_ip_ranges_to_nats=["ALL_IP_RANGES"],
-            )])
-        ```
-        ### Router Nat Rules
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        net = gcp.compute.Network("net", auto_create_subnetworks=False)
-        subnet = gcp.compute.Subnetwork("subnet",
-            network=net.id,
-            ip_cidr_range="10.0.0.0/16",
-            region="us-central1")
-        router = gcp.compute.Router("router",
-            region=subnet.region,
-            network=net.id)
-        addr1 = gcp.compute.Address("addr1", region=subnet.region)
-        addr2 = gcp.compute.Address("addr2", region=subnet.region)
-        addr3 = gcp.compute.Address("addr3", region=subnet.region)
-        nat_rules = gcp.compute.RouterNat("natRules",
-            router=router.name,
-            region=router.region,
-            nat_ip_allocate_option="MANUAL_ONLY",
-            nat_ips=[addr1.self_link],
-            source_subnetwork_ip_ranges_to_nat="LIST_OF_SUBNETWORKS",
-            subnetworks=[gcp.compute.RouterNatSubnetworkArgs(
-                name=subnet.id,
-                source_ip_ranges_to_nats=["ALL_IP_RANGES"],
-            )],
-            rules=[gcp.compute.RouterNatRuleArgs(
-                rule_number=100,
-                description="nat rules example",
-                match="inIpRange(destination.ip, '1.1.0.0/16') || inIpRange(destination.ip, '2.2.0.0/16')",
-                action=gcp.compute.RouterNatRuleActionArgs(
-                    source_nat_active_ips=[
-                        addr2.self_link,
-                        addr3.self_link,
-                    ],
-                ),
-            )],
-            enable_endpoint_independent_mapping=False)
-        ```
 
         ## Import
 
@@ -1121,101 +1092,6 @@ class RouterNat(pulumi.CustomResource):
             * [Google Cloud Router](https://cloud.google.com/router/docs/)
 
         ## Example Usage
-        ### Router Nat Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        net = gcp.compute.Network("net")
-        subnet = gcp.compute.Subnetwork("subnet",
-            network=net.id,
-            ip_cidr_range="10.0.0.0/16",
-            region="us-central1")
-        router = gcp.compute.Router("router",
-            region=subnet.region,
-            network=net.id,
-            bgp=gcp.compute.RouterBgpArgs(
-                asn=64514,
-            ))
-        nat = gcp.compute.RouterNat("nat",
-            router=router.name,
-            region=router.region,
-            nat_ip_allocate_option="AUTO_ONLY",
-            source_subnetwork_ip_ranges_to_nat="ALL_SUBNETWORKS_ALL_IP_RANGES",
-            log_config=gcp.compute.RouterNatLogConfigArgs(
-                enable=True,
-                filter="ERRORS_ONLY",
-            ))
-        ```
-        ### Router Nat Manual Ips
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        net = gcp.compute.Network("net")
-        subnet = gcp.compute.Subnetwork("subnet",
-            network=net.id,
-            ip_cidr_range="10.0.0.0/16",
-            region="us-central1")
-        router = gcp.compute.Router("router",
-            region=subnet.region,
-            network=net.id)
-        address = []
-        for range in [{"value": i} for i in range(0, 2)]:
-            address.append(gcp.compute.Address(f"address-{range['value']}", region=subnet.region))
-        nat_manual = gcp.compute.RouterNat("natManual",
-            router=router.name,
-            region=router.region,
-            nat_ip_allocate_option="MANUAL_ONLY",
-            nat_ips=[__item.self_link for __item in address],
-            source_subnetwork_ip_ranges_to_nat="LIST_OF_SUBNETWORKS",
-            subnetworks=[gcp.compute.RouterNatSubnetworkArgs(
-                name=subnet.id,
-                source_ip_ranges_to_nats=["ALL_IP_RANGES"],
-            )])
-        ```
-        ### Router Nat Rules
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        net = gcp.compute.Network("net", auto_create_subnetworks=False)
-        subnet = gcp.compute.Subnetwork("subnet",
-            network=net.id,
-            ip_cidr_range="10.0.0.0/16",
-            region="us-central1")
-        router = gcp.compute.Router("router",
-            region=subnet.region,
-            network=net.id)
-        addr1 = gcp.compute.Address("addr1", region=subnet.region)
-        addr2 = gcp.compute.Address("addr2", region=subnet.region)
-        addr3 = gcp.compute.Address("addr3", region=subnet.region)
-        nat_rules = gcp.compute.RouterNat("natRules",
-            router=router.name,
-            region=router.region,
-            nat_ip_allocate_option="MANUAL_ONLY",
-            nat_ips=[addr1.self_link],
-            source_subnetwork_ip_ranges_to_nat="LIST_OF_SUBNETWORKS",
-            subnetworks=[gcp.compute.RouterNatSubnetworkArgs(
-                name=subnet.id,
-                source_ip_ranges_to_nats=["ALL_IP_RANGES"],
-            )],
-            rules=[gcp.compute.RouterNatRuleArgs(
-                rule_number=100,
-                description="nat rules example",
-                match="inIpRange(destination.ip, '1.1.0.0/16') || inIpRange(destination.ip, '2.2.0.0/16')",
-                action=gcp.compute.RouterNatRuleActionArgs(
-                    source_nat_active_ips=[
-                        addr2.self_link,
-                        addr3.self_link,
-                    ],
-                ),
-            )],
-            enable_endpoint_independent_mapping=False)
-        ```
 
         ## Import
 
@@ -1289,11 +1165,7 @@ class RouterNat(pulumi.CustomResource):
             __props__.__dict__["enable_dynamic_port_allocation"] = enable_dynamic_port_allocation
             __props__.__dict__["enable_endpoint_independent_mapping"] = enable_endpoint_independent_mapping
             __props__.__dict__["icmp_idle_timeout_sec"] = icmp_idle_timeout_sec
-            if log_config is not None and not isinstance(log_config, RouterNatLogConfigArgs):
-                log_config = log_config or {}
-                def _setter(key, value):
-                    log_config[key] = value
-                RouterNatLogConfigArgs._configure(_setter, **log_config)
+            log_config = _utilities.configure(log_config, RouterNatLogConfigArgs, True)
             __props__.__dict__["log_config"] = log_config
             __props__.__dict__["max_ports_per_vm"] = max_ports_per_vm
             __props__.__dict__["min_ports_per_vm"] = min_ports_per_vm