pulumi-gcp 7.12.0a1709102105__py3-none-any.whl → 7.12.0a1709149267__py3-none-any.whl

pulumi_gcp/compute/machine_image_iam_policy.py

@@ -229,10 +229,9 @@ class MachineImageIamPolicy(pulumi.CustomResource):
             members=["user:jane@example.com"],
         )])
         policy = gcp.compute.MachineImageIamPolicy("policy",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
-            policy_data=admin.policy_data,
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            project=image["project"],
+            machine_image=image["name"],
+            policy_data=admin.policy_data)
         ```
 
         With IAM Conditions:
@@ -251,10 +250,9 @@ class MachineImageIamPolicy(pulumi.CustomResource):
             ),
         )])
         policy = gcp.compute.MachineImageIamPolicy("policy",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
-            policy_data=admin.policy_data,
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            project=image["project"],
+            machine_image=image["name"],
+            policy_data=admin.policy_data)
         ```
         ## google\\_compute\\_machine\\_image\\_iam\\_binding
 
@@ -263,11 +261,10 @@ class MachineImageIamPolicy(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         binding = gcp.compute.MachineImageIamBinding("binding",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
+            project=image["project"],
+            machine_image=image["name"],
             role="roles/compute.admin",
-            members=["user:jane@example.com"],
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            members=["user:jane@example.com"])
         ```
 
         With IAM Conditions:
@@ -277,16 +274,15 @@ class MachineImageIamPolicy(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         binding = gcp.compute.MachineImageIamBinding("binding",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
+            project=image["project"],
+            machine_image=image["name"],
             role="roles/compute.admin",
             members=["user:jane@example.com"],
             condition=gcp.compute.MachineImageIamBindingConditionArgs(
                 title="expires_after_2019_12_31",
                 description="Expiring at midnight of 2019-12-31",
                 expression="request.time < timestamp(\\"2020-01-01T00:00:00Z\\")",
-            ),
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            ))
         ```
         ## google\\_compute\\_machine\\_image\\_iam\\_member
 
@@ -295,11 +291,10 @@ class MachineImageIamPolicy(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         member = gcp.compute.MachineImageIamMember("member",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
+            project=image["project"],
+            machine_image=image["name"],
             role="roles/compute.admin",
-            member="user:jane@example.com",
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            member="user:jane@example.com")
         ```
 
         With IAM Conditions:
@@ -309,16 +304,15 @@ class MachineImageIamPolicy(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         member = gcp.compute.MachineImageIamMember("member",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
+            project=image["project"],
+            machine_image=image["name"],
             role="roles/compute.admin",
             member="user:jane@example.com",
             condition=gcp.compute.MachineImageIamMemberConditionArgs(
                 title="expires_after_2019_12_31",
                 description="Expiring at midnight of 2019-12-31",
                 expression="request.time < timestamp(\\"2020-01-01T00:00:00Z\\")",
-            ),
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            ))
         ```
 
         ## Import
@@ -410,10 +404,9 @@ class MachineImageIamPolicy(pulumi.CustomResource):
             members=["user:jane@example.com"],
         )])
         policy = gcp.compute.MachineImageIamPolicy("policy",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
-            policy_data=admin.policy_data,
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            project=image["project"],
+            machine_image=image["name"],
+            policy_data=admin.policy_data)
         ```
 
         With IAM Conditions:
@@ -432,10 +425,9 @@ class MachineImageIamPolicy(pulumi.CustomResource):
             ),
         )])
         policy = gcp.compute.MachineImageIamPolicy("policy",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
-            policy_data=admin.policy_data,
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            project=image["project"],
+            machine_image=image["name"],
+            policy_data=admin.policy_data)
         ```
         ## google\\_compute\\_machine\\_image\\_iam\\_binding
 
@@ -444,11 +436,10 @@ class MachineImageIamPolicy(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         binding = gcp.compute.MachineImageIamBinding("binding",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
+            project=image["project"],
+            machine_image=image["name"],
             role="roles/compute.admin",
-            members=["user:jane@example.com"],
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            members=["user:jane@example.com"])
         ```
 
         With IAM Conditions:
@@ -458,16 +449,15 @@ class MachineImageIamPolicy(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         binding = gcp.compute.MachineImageIamBinding("binding",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
+            project=image["project"],
+            machine_image=image["name"],
             role="roles/compute.admin",
             members=["user:jane@example.com"],
             condition=gcp.compute.MachineImageIamBindingConditionArgs(
                 title="expires_after_2019_12_31",
                 description="Expiring at midnight of 2019-12-31",
                 expression="request.time < timestamp(\\"2020-01-01T00:00:00Z\\")",
-            ),
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            ))
         ```
         ## google\\_compute\\_machine\\_image\\_iam\\_member
 
@@ -476,11 +466,10 @@ class MachineImageIamPolicy(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         member = gcp.compute.MachineImageIamMember("member",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
+            project=image["project"],
+            machine_image=image["name"],
             role="roles/compute.admin",
-            member="user:jane@example.com",
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            member="user:jane@example.com")
         ```
 
         With IAM Conditions:
@@ -490,16 +479,15 @@ class MachineImageIamPolicy(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         member = gcp.compute.MachineImageIamMember("member",
-            project=google_compute_machine_image["image"]["project"],
-            machine_image=google_compute_machine_image["image"]["name"],
+            project=image["project"],
+            machine_image=image["name"],
             role="roles/compute.admin",
             member="user:jane@example.com",
             condition=gcp.compute.MachineImageIamMemberConditionArgs(
                 title="expires_after_2019_12_31",
                 description="Expiring at midnight of 2019-12-31",
                 expression="request.time < timestamp(\\"2020-01-01T00:00:00Z\\")",
-            ),
-            opts=pulumi.ResourceOptions(provider=google_beta))
+            ))
         ```
 
         ## Import

pulumi_gcp/compute/managed_ssl_certificate.py

@@ -381,6 +381,112 @@ class ManagedSslCertificate(pulumi.CustomResource):
         In conclusion: Be extremely cautious.
 
         ## Example Usage
+        ### Managed Ssl Certificate Basic
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default = gcp.compute.ManagedSslCertificate("default",
+            name="test-cert",
+            managed=gcp.compute.ManagedSslCertificateManagedArgs(
+                domains=["sslcert.tf-test.club."],
+            ))
+        default_http_health_check = gcp.compute.HttpHealthCheck("default",
+            name="http-health-check",
+            request_path="/",
+            check_interval_sec=1,
+            timeout_sec=1)
+        default_backend_service = gcp.compute.BackendService("default",
+            name="backend-service",
+            port_name="http",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_http_health_check.id)
+        default_url_map = gcp.compute.URLMap("default",
+            name="url-map",
+            description="a description",
+            default_service=default_backend_service.id,
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["sslcert.tf-test.club"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
+        default_target_https_proxy = gcp.compute.TargetHttpsProxy("default",
+            name="test-proxy",
+            url_map=default_url_map.id,
+            ssl_certificates=[default.id])
+        default_global_forwarding_rule = gcp.compute.GlobalForwardingRule("default",
+            name="forwarding-rule",
+            target=default_target_https_proxy.id,
+            port_range="443")
+        ```
+        ### Managed Ssl Certificate Recreation
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+        import pulumi_random as random
+        import pulumi_std as std
+
+
+        def not_implemented(msg):
+            raise NotImplementedError(msg)
+
+        managed_domains = not_implemented("tolist([\\"test.example.com\\"])")
+        certificate = random.RandomId("certificate",
+            byte_length=4,
+            prefix="issue6147-cert-",
+            keepers={
+                "domains": std.join(separator=",",
+                    input=managed_domains).result,
+            })
+        cert = gcp.compute.ManagedSslCertificate("cert",
+            name=certificate.hex,
+            managed=gcp.compute.ManagedSslCertificateManagedArgs(
+                domains=managed_domains,
+            ))
+        default_http_health_check = gcp.compute.HttpHealthCheck("default",
+            name="http-health-check",
+            request_path="/",
+            check_interval_sec=1,
+            timeout_sec=1)
+        default_backend_service = gcp.compute.BackendService("default",
+            name="backend-service",
+            port_name="http",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_http_health_check.id)
+        default_url_map = gcp.compute.URLMap("default",
+            name="url-map",
+            description="a description",
+            default_service=default_backend_service.id,
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
+        # This example allows the list of managed domains to be modified and will
+        # recreate the ssl certificate and update the target https proxy correctly
+        default = gcp.compute.TargetHttpsProxy("default",
+            name="test-proxy",
+            url_map=default_url_map.id,
+            ssl_certificates=[cert.id])
+        ```
 
         ## Import
 
@@ -463,6 +569,112 @@ class ManagedSslCertificate(pulumi.CustomResource):
         In conclusion: Be extremely cautious.
 
         ## Example Usage
+        ### Managed Ssl Certificate Basic
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default = gcp.compute.ManagedSslCertificate("default",
+            name="test-cert",
+            managed=gcp.compute.ManagedSslCertificateManagedArgs(
+                domains=["sslcert.tf-test.club."],
+            ))
+        default_http_health_check = gcp.compute.HttpHealthCheck("default",
+            name="http-health-check",
+            request_path="/",
+            check_interval_sec=1,
+            timeout_sec=1)
+        default_backend_service = gcp.compute.BackendService("default",
+            name="backend-service",
+            port_name="http",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_http_health_check.id)
+        default_url_map = gcp.compute.URLMap("default",
+            name="url-map",
+            description="a description",
+            default_service=default_backend_service.id,
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["sslcert.tf-test.club"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
+        default_target_https_proxy = gcp.compute.TargetHttpsProxy("default",
+            name="test-proxy",
+            url_map=default_url_map.id,
+            ssl_certificates=[default.id])
+        default_global_forwarding_rule = gcp.compute.GlobalForwardingRule("default",
+            name="forwarding-rule",
+            target=default_target_https_proxy.id,
+            port_range="443")
+        ```
+        ### Managed Ssl Certificate Recreation
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+        import pulumi_random as random
+        import pulumi_std as std
+
+
+        def not_implemented(msg):
+            raise NotImplementedError(msg)
+
+        managed_domains = not_implemented("tolist([\\"test.example.com\\"])")
+        certificate = random.RandomId("certificate",
+            byte_length=4,
+            prefix="issue6147-cert-",
+            keepers={
+                "domains": std.join(separator=",",
+                    input=managed_domains).result,
+            })
+        cert = gcp.compute.ManagedSslCertificate("cert",
+            name=certificate.hex,
+            managed=gcp.compute.ManagedSslCertificateManagedArgs(
+                domains=managed_domains,
+            ))
+        default_http_health_check = gcp.compute.HttpHealthCheck("default",
+            name="http-health-check",
+            request_path="/",
+            check_interval_sec=1,
+            timeout_sec=1)
+        default_backend_service = gcp.compute.BackendService("default",
+            name="backend-service",
+            port_name="http",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_http_health_check.id)
+        default_url_map = gcp.compute.URLMap("default",
+            name="url-map",
+            description="a description",
+            default_service=default_backend_service.id,
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
+        # This example allows the list of managed domains to be modified and will
+        # recreate the ssl certificate and update the target https proxy correctly
+        default = gcp.compute.TargetHttpsProxy("default",
+            name="test-proxy",
+            url_map=default_url_map.id,
+            ssl_certificates=[cert.id])
+        ```
 
         ## Import
 

pulumi_gcp/compute/manged_ssl_certificate.py

@@ -386,6 +386,112 @@ class MangedSslCertificate(pulumi.CustomResource):
         In conclusion: Be extremely cautious.
 
         ## Example Usage
+        ### Managed Ssl Certificate Basic
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default = gcp.compute.ManagedSslCertificate("default",
+            name="test-cert",
+            managed=gcp.compute.ManagedSslCertificateManagedArgs(
+                domains=["sslcert.tf-test.club."],
+            ))
+        default_http_health_check = gcp.compute.HttpHealthCheck("default",
+            name="http-health-check",
+            request_path="/",
+            check_interval_sec=1,
+            timeout_sec=1)
+        default_backend_service = gcp.compute.BackendService("default",
+            name="backend-service",
+            port_name="http",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_http_health_check.id)
+        default_url_map = gcp.compute.URLMap("default",
+            name="url-map",
+            description="a description",
+            default_service=default_backend_service.id,
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["sslcert.tf-test.club"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
+        default_target_https_proxy = gcp.compute.TargetHttpsProxy("default",
+            name="test-proxy",
+            url_map=default_url_map.id,
+            ssl_certificates=[default.id])
+        default_global_forwarding_rule = gcp.compute.GlobalForwardingRule("default",
+            name="forwarding-rule",
+            target=default_target_https_proxy.id,
+            port_range="443")
+        ```
+        ### Managed Ssl Certificate Recreation
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+        import pulumi_random as random
+        import pulumi_std as std
+
+
+        def not_implemented(msg):
+            raise NotImplementedError(msg)
+
+        managed_domains = not_implemented("tolist([\\"test.example.com\\"])")
+        certificate = random.RandomId("certificate",
+            byte_length=4,
+            prefix="issue6147-cert-",
+            keepers={
+                "domains": std.join(separator=",",
+                    input=managed_domains).result,
+            })
+        cert = gcp.compute.ManagedSslCertificate("cert",
+            name=certificate.hex,
+            managed=gcp.compute.ManagedSslCertificateManagedArgs(
+                domains=managed_domains,
+            ))
+        default_http_health_check = gcp.compute.HttpHealthCheck("default",
+            name="http-health-check",
+            request_path="/",
+            check_interval_sec=1,
+            timeout_sec=1)
+        default_backend_service = gcp.compute.BackendService("default",
+            name="backend-service",
+            port_name="http",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_http_health_check.id)
+        default_url_map = gcp.compute.URLMap("default",
+            name="url-map",
+            description="a description",
+            default_service=default_backend_service.id,
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
+        # This example allows the list of managed domains to be modified and will
+        # recreate the ssl certificate and update the target https proxy correctly
+        default = gcp.compute.TargetHttpsProxy("default",
+            name="test-proxy",
+            url_map=default_url_map.id,
+            ssl_certificates=[cert.id])
+        ```
 
         ## Import
 
@@ -468,6 +574,112 @@ class MangedSslCertificate(pulumi.CustomResource):
         In conclusion: Be extremely cautious.
 
         ## Example Usage
+        ### Managed Ssl Certificate Basic
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default = gcp.compute.ManagedSslCertificate("default",
+            name="test-cert",
+            managed=gcp.compute.ManagedSslCertificateManagedArgs(
+                domains=["sslcert.tf-test.club."],
+            ))
+        default_http_health_check = gcp.compute.HttpHealthCheck("default",
+            name="http-health-check",
+            request_path="/",
+            check_interval_sec=1,
+            timeout_sec=1)
+        default_backend_service = gcp.compute.BackendService("default",
+            name="backend-service",
+            port_name="http",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_http_health_check.id)
+        default_url_map = gcp.compute.URLMap("default",
+            name="url-map",
+            description="a description",
+            default_service=default_backend_service.id,
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["sslcert.tf-test.club"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
+        default_target_https_proxy = gcp.compute.TargetHttpsProxy("default",
+            name="test-proxy",
+            url_map=default_url_map.id,
+            ssl_certificates=[default.id])
+        default_global_forwarding_rule = gcp.compute.GlobalForwardingRule("default",
+            name="forwarding-rule",
+            target=default_target_https_proxy.id,
+            port_range="443")
+        ```
+        ### Managed Ssl Certificate Recreation
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+        import pulumi_random as random
+        import pulumi_std as std
+
+
+        def not_implemented(msg):
+            raise NotImplementedError(msg)
+
+        managed_domains = not_implemented("tolist([\\"test.example.com\\"])")
+        certificate = random.RandomId("certificate",
+            byte_length=4,
+            prefix="issue6147-cert-",
+            keepers={
+                "domains": std.join(separator=",",
+                    input=managed_domains).result,
+            })
+        cert = gcp.compute.ManagedSslCertificate("cert",
+            name=certificate.hex,
+            managed=gcp.compute.ManagedSslCertificateManagedArgs(
+                domains=managed_domains,
+            ))
+        default_http_health_check = gcp.compute.HttpHealthCheck("default",
+            name="http-health-check",
+            request_path="/",
+            check_interval_sec=1,
+            timeout_sec=1)
+        default_backend_service = gcp.compute.BackendService("default",
+            name="backend-service",
+            port_name="http",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_http_health_check.id)
+        default_url_map = gcp.compute.URLMap("default",
+            name="url-map",
+            description="a description",
+            default_service=default_backend_service.id,
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
+        # This example allows the list of managed domains to be modified and will
+        # recreate the ssl certificate and update the target https proxy correctly
+        default = gcp.compute.TargetHttpsProxy("default",
+            name="test-proxy",
+            url_map=default_url_map.id,
+            ssl_certificates=[cert.id])
+        ```
 
         ## Import