pulumi-confluentcloud 2.49.0a1761153138__py3-none-any.whl → 2.50.0__py3-none-any.whl

pulumi_confluentcloud/api_key.py

@@ -225,12 +225,96 @@ class ApiKey(pulumi.CustomResource):
         ## Example Usage
 
         ### Example Kafka API Key
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+
+        app_manager_kafka_api_key = confluentcloud.ApiKey("app-manager-kafka-api-key",
+            display_name="app-manager-kafka-api-key",
+            description="Kafka API Key that is owned by 'app-manager' service account",
+            owner={
+                "id": app_manager["id"],
+                "api_version": app_manager["apiVersion"],
+                "kind": app_manager["kind"],
+            },
+            managed_resource={
+                "id": basic["id"],
+                "api_version": basic["apiVersion"],
+                "kind": basic["kind"],
+                "environments": [{
+                    "id": staging["id"],
+                }],
+            })
+        ```
 
         ### Example ksqlDB API Key
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+
+        ksqldb_api_key = confluentcloud.ApiKey("ksqldb-api-key",
+            display_name="ksqldb-api-key",
+            description="KsqlDB API Key that is owned by 'app-manager' service account",
+            owner={
+                "id": app_manager["id"],
+                "api_version": app_manager["apiVersion"],
+                "kind": app_manager["kind"],
+            },
+            managed_resource={
+                "id": main["id"],
+                "api_version": main["apiVersion"],
+                "kind": main["kind"],
+                "environments": [{
+                    "id": staging["id"],
+                }],
+            })
+        ```
 
         ### Example Schema Registry API Key
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+
+        env_manager_schema_registry_api_key = confluentcloud.ApiKey("env-manager-schema-registry-api-key",
+            display_name="env-manager-schema-registry-api-key",
+            description="Schema Registry API Key that is owned by 'env-manager' service account",
+            owner={
+                "id": env_manager["id"],
+                "api_version": env_manager["apiVersion"],
+                "kind": env_manager["kind"],
+            },
+            managed_resource={
+                "id": essentials["id"],
+                "api_version": essentials["apiVersion"],
+                "kind": essentials["kind"],
+                "environments": [{
+                    "id": staging["id"],
+                }],
+            })
+        ```
 
         ### Example Flink API Key
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+
+        env_manager_flink_api_key = confluentcloud.ApiKey("env-manager-flink-api-key",
+            display_name="env-manager-flink-api-key",
+            description="Flink API Key that is owned by 'env-manager' service account",
+            owner={
+                "id": env_manager["id"],
+                "api_version": env_manager["apiVersion"],
+                "kind": env_manager["kind"],
+            },
+            managed_resource={
+                "id": example["id"],
+                "api_version": example["apiVersion"],
+                "kind": example["kind"],
+                "environments": [{
+                    "id": staging["id"],
+                }],
+            })
+        ```
 
         ### Example Tableflow API Key
         ```python
@@ -342,12 +426,96 @@ class ApiKey(pulumi.CustomResource):
         ## Example Usage
 
         ### Example Kafka API Key
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+
+        app_manager_kafka_api_key = confluentcloud.ApiKey("app-manager-kafka-api-key",
+            display_name="app-manager-kafka-api-key",
+            description="Kafka API Key that is owned by 'app-manager' service account",
+            owner={
+                "id": app_manager["id"],
+                "api_version": app_manager["apiVersion"],
+                "kind": app_manager["kind"],
+            },
+            managed_resource={
+                "id": basic["id"],
+                "api_version": basic["apiVersion"],
+                "kind": basic["kind"],
+                "environments": [{
+                    "id": staging["id"],
+                }],
+            })
+        ```
 
         ### Example ksqlDB API Key
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+
+        ksqldb_api_key = confluentcloud.ApiKey("ksqldb-api-key",
+            display_name="ksqldb-api-key",
+            description="KsqlDB API Key that is owned by 'app-manager' service account",
+            owner={
+                "id": app_manager["id"],
+                "api_version": app_manager["apiVersion"],
+                "kind": app_manager["kind"],
+            },
+            managed_resource={
+                "id": main["id"],
+                "api_version": main["apiVersion"],
+                "kind": main["kind"],
+                "environments": [{
+                    "id": staging["id"],
+                }],
+            })
+        ```
 
         ### Example Schema Registry API Key
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+
+        env_manager_schema_registry_api_key = confluentcloud.ApiKey("env-manager-schema-registry-api-key",
+            display_name="env-manager-schema-registry-api-key",
+            description="Schema Registry API Key that is owned by 'env-manager' service account",
+            owner={
+                "id": env_manager["id"],
+                "api_version": env_manager["apiVersion"],
+                "kind": env_manager["kind"],
+            },
+            managed_resource={
+                "id": essentials["id"],
+                "api_version": essentials["apiVersion"],
+                "kind": essentials["kind"],
+                "environments": [{
+                    "id": staging["id"],
+                }],
+            })
+        ```
 
         ### Example Flink API Key
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+
+        env_manager_flink_api_key = confluentcloud.ApiKey("env-manager-flink-api-key",
+            display_name="env-manager-flink-api-key",
+            description="Flink API Key that is owned by 'env-manager' service account",
+            owner={
+                "id": env_manager["id"],
+                "api_version": env_manager["apiVersion"],
+                "kind": env_manager["kind"],
+            },
+            managed_resource={
+                "id": example["id"],
+                "api_version": example["apiVersion"],
+                "kind": example["kind"],
+                "environments": [{
+                    "id": staging["id"],
+                }],
+            })
+        ```
 
         ### Example Tableflow API Key
         ```python

pulumi_confluentcloud/dns_forwarder.py

@@ -248,6 +248,30 @@ class DnsForwarder(pulumi.CustomResource):
 
         ### Option #2: Create using ForwardViaGcpDnsZones method
 
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+
+        development = confluentcloud.Environment("development", display_name="Development")
+        main = confluentcloud.DnsForwarder("main",
+            display_name="dns_forwarder",
+            environment={
+                "id": development.id,
+            },
+            domains=[
+                "example.com",
+                "domainname.com",
+            ],
+            gateway={
+                "id": main_confluent_network["gateway"][0]["id"],
+            },
+            forward_via_gcp_zones=[{
+                "domainMappings": {
+                    "example.com": "zone-1,project-1",
+                },
+            }])
+        ```
+
         ## Import
 
         You can import a DNS Forwarder by using Environment ID and DNS Forwarder ID, in the format `<Environment ID>/<DNS Forwarder ID>`. The following example shows how to import a DNS Forwarder:
@@ -310,6 +334,30 @@ class DnsForwarder(pulumi.CustomResource):
 
         ### Option #2: Create using ForwardViaGcpDnsZones method
 
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+
+        development = confluentcloud.Environment("development", display_name="Development")
+        main = confluentcloud.DnsForwarder("main",
+            display_name="dns_forwarder",
+            environment={
+                "id": development.id,
+            },
+            domains=[
+                "example.com",
+                "domainname.com",
+            ],
+            gateway={
+                "id": main_confluent_network["gateway"][0]["id"],
+            },
+            forward_via_gcp_zones=[{
+                "domainMappings": {
+                    "example.com": "zone-1,project-1",
+                },
+            }])
+        ```
+
         ## Import
 
         You can import a DNS Forwarder by using Environment ID and DNS Forwarder ID, in the format `<Environment ID>/<DNS Forwarder ID>`. The following example shows how to import a DNS Forwarder:

pulumi_confluentcloud/get_catalog_integration.py

@@ -135,6 +135,36 @@ def get_catalog_integration(credentials: Optional[Union['GetCatalogIntegrationCr
 
     ## Example Usage
 
+    ### Option #1: Manage multiple Catalog Integrations in the same Pulumi Stack
+
+    ```python
+    import pulumi
+    import pulumi_confluentcloud as confluentcloud
+
+    example = confluentcloud.get_catalog_integration(environment={
+            "id": staging["id"],
+        },
+        kafka_cluster={
+            "id": staging_confluent_kafka_cluster["id"],
+        },
+        id="tci-abc123",
+        credentials={
+            "key": env_admin_tableflow_api_key["id"],
+            "secret": env_admin_tableflow_api_key["secret"],
+        })
+    pulumi.export("retention-ms", example.retention_ms)
+    ```
+
+    ### Option #2: Manage a single Catalog Integration in the same Pulumi Stack
+
+    ```python
+    import pulumi
+    import pulumi_confluentcloud as confluentcloud
+
+    example = confluentcloud.get_catalog_integration(id="tci-abc123")
+    pulumi.export("retention-ms", example.retention_ms)
+    ```
+
 
     :param _builtins.str id: The ID of the Catalog Integration, for example, `tci-abc123`.
     """
@@ -167,6 +197,36 @@ def get_catalog_integration_output(credentials: Optional[pulumi.Input[Optional[U
 
     ## Example Usage
 
+    ### Option #1: Manage multiple Catalog Integrations in the same Pulumi Stack
+
+    ```python
+    import pulumi
+    import pulumi_confluentcloud as confluentcloud
+
+    example = confluentcloud.get_catalog_integration(environment={
+            "id": staging["id"],
+        },
+        kafka_cluster={
+            "id": staging_confluent_kafka_cluster["id"],
+        },
+        id="tci-abc123",
+        credentials={
+            "key": env_admin_tableflow_api_key["id"],
+            "secret": env_admin_tableflow_api_key["secret"],
+        })
+    pulumi.export("retention-ms", example.retention_ms)
+    ```
+
+    ### Option #2: Manage a single Catalog Integration in the same Pulumi Stack
+
+    ```python
+    import pulumi
+    import pulumi_confluentcloud as confluentcloud
+
+    example = confluentcloud.get_catalog_integration(id="tci-abc123")
+    pulumi.export("retention-ms", example.retention_ms)
+    ```
+
 
     :param _builtins.str id: The ID of the Catalog Integration, for example, `tci-abc123`.
     """

pulumi_confluentcloud/get_kafka_clusters.py

@@ -0,0 +1,136 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+from . import outputs
+from ._inputs import *
+
+__all__ = [
+    'GetKafkaClustersResult',
+    'AwaitableGetKafkaClustersResult',
+    'get_kafka_clusters',
+    'get_kafka_clusters_output',
+]
+
+@pulumi.output_type
+class GetKafkaClustersResult:
+    """
+    A collection of values returned by getKafkaClusters.
+    """
+    def __init__(__self__, clusters=None, environment=None, id=None):
+        if clusters and not isinstance(clusters, list):
+            raise TypeError("Expected argument 'clusters' to be a list")
+        pulumi.set(__self__, "clusters", clusters)
+        if environment and not isinstance(environment, dict):
+            raise TypeError("Expected argument 'environment' to be a dict")
+        pulumi.set(__self__, "environment", environment)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def clusters(self) -> Sequence['outputs.GetKafkaClustersClusterResult']:
+        """
+        (Required List of Object) List of Kafka clusters. Each Kafka cluster object exports the following attributes:
+        """
+        return pulumi.get(self, "clusters")
+
+    @_builtins.property
+    @pulumi.getter
+    def environment(self) -> 'outputs.GetKafkaClustersEnvironmentResult':
+        """
+        (Required Object) exports the following attributes:
+        """
+        return pulumi.get(self, "environment")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+
+class AwaitableGetKafkaClustersResult(GetKafkaClustersResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetKafkaClustersResult(
+            clusters=self.clusters,
+            environment=self.environment,
+            id=self.id)
+
+
+def get_kafka_clusters(environment: Optional[Union['GetKafkaClustersEnvironmentArgs', 'GetKafkaClustersEnvironmentArgsDict']] = None,
+                       opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetKafkaClustersResult:
+    """
+    [![General Availability](https://img.shields.io/badge/Lifecycle%20Stage-General%20Availability-%2345c6e8)](https://docs.confluent.io/cloud/current/api.html#section/Versioning/API-Lifecycle-Policy)
+
+    `get_kafka_clusters` describes a data source for Kafka Clusters.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_confluentcloud as confluentcloud
+
+    main = confluentcloud.get_kafka_clusters(environment={
+        "id": "env-123abc",
+    })
+    ```
+
+
+    :param Union['GetKafkaClustersEnvironmentArgs', 'GetKafkaClustersEnvironmentArgsDict'] environment: (Required Object) exports the following attributes:
+    """
+    __args__ = dict()
+    __args__['environment'] = environment
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('confluentcloud:index/getKafkaClusters:getKafkaClusters', __args__, opts=opts, typ=GetKafkaClustersResult).value
+
+    return AwaitableGetKafkaClustersResult(
+        clusters=pulumi.get(__ret__, 'clusters'),
+        environment=pulumi.get(__ret__, 'environment'),
+        id=pulumi.get(__ret__, 'id'))
+def get_kafka_clusters_output(environment: Optional[pulumi.Input[Union['GetKafkaClustersEnvironmentArgs', 'GetKafkaClustersEnvironmentArgsDict']]] = None,
+                              opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetKafkaClustersResult]:
+    """
+    [![General Availability](https://img.shields.io/badge/Lifecycle%20Stage-General%20Availability-%2345c6e8)](https://docs.confluent.io/cloud/current/api.html#section/Versioning/API-Lifecycle-Policy)
+
+    `get_kafka_clusters` describes a data source for Kafka Clusters.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_confluentcloud as confluentcloud
+
+    main = confluentcloud.get_kafka_clusters(environment={
+        "id": "env-123abc",
+    })
+    ```
+
+
+    :param Union['GetKafkaClustersEnvironmentArgs', 'GetKafkaClustersEnvironmentArgsDict'] environment: (Required Object) exports the following attributes:
+    """
+    __args__ = dict()
+    __args__['environment'] = environment
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('confluentcloud:index/getKafkaClusters:getKafkaClusters', __args__, opts=opts, typ=GetKafkaClustersResult)
+    return __ret__.apply(lambda __response__: GetKafkaClustersResult(
+        clusters=pulumi.get(__response__, 'clusters'),
+        environment=pulumi.get(__response__, 'environment'),
+        id=pulumi.get(__response__, 'id')))

pulumi_confluentcloud/get_private_link_attachment.py

@@ -73,7 +73,6 @@ class GetPrivateLinkAttachmentResult:
     def azures(self) -> Sequence['outputs.GetPrivateLinkAttachmentAzureResult']:
         """
         (Optional Configuration Block) supports the following:
-        - `private_link_service_alias ` - (Required String) Azure Private Link service alias for the availability zone.
         """
         return pulumi.get(self, "azures")
 

pulumi_confluentcloud/get_provider_integration_authorization.py

@@ -0,0 +1,142 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+from . import outputs
+from ._inputs import *
+
+__all__ = [
+    'GetProviderIntegrationAuthorizationResult',
+    'AwaitableGetProviderIntegrationAuthorizationResult',
+    'get_provider_integration_authorization',
+    'get_provider_integration_authorization_output',
+]
+
+@pulumi.output_type
+class GetProviderIntegrationAuthorizationResult:
+    """
+    A collection of values returned by getProviderIntegrationAuthorization.
+    """
+    def __init__(__self__, azures=None, environment=None, gcps=None, id=None, provider_integration_id=None):
+        if azures and not isinstance(azures, list):
+            raise TypeError("Expected argument 'azures' to be a list")
+        pulumi.set(__self__, "azures", azures)
+        if environment and not isinstance(environment, dict):
+            raise TypeError("Expected argument 'environment' to be a dict")
+        pulumi.set(__self__, "environment", environment)
+        if gcps and not isinstance(gcps, list):
+            raise TypeError("Expected argument 'gcps' to be a list")
+        pulumi.set(__self__, "gcps", gcps)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if provider_integration_id and not isinstance(provider_integration_id, str):
+            raise TypeError("Expected argument 'provider_integration_id' to be a str")
+        pulumi.set(__self__, "provider_integration_id", provider_integration_id)
+
+    @_builtins.property
+    @pulumi.getter
+    def azures(self) -> Sequence['outputs.GetProviderIntegrationAuthorizationAzureResult']:
+        """
+        (Optional Configuration Block) Azure-specific configuration details. Present for Azure integrations. It supports the following:
+        """
+        return pulumi.get(self, "azures")
+
+    @_builtins.property
+    @pulumi.getter
+    def environment(self) -> 'outputs.GetProviderIntegrationAuthorizationEnvironmentResult':
+        """
+        (Required Configuration Block) supports the following:
+        """
+        return pulumi.get(self, "environment")
+
+    @_builtins.property
+    @pulumi.getter
+    def gcps(self) -> Sequence['outputs.GetProviderIntegrationAuthorizationGcpResult']:
+        """
+        (Optional Configuration Block) GCP-specific configuration details. Present for GCP integrations. It supports the following:
+        """
+        return pulumi.get(self, "gcps")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        (Required String) The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="providerIntegrationId")
+    def provider_integration_id(self) -> _builtins.str:
+        """
+        (Required String) The ID of the provider integration.
+        """
+        return pulumi.get(self, "provider_integration_id")
+
+
+class AwaitableGetProviderIntegrationAuthorizationResult(GetProviderIntegrationAuthorizationResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetProviderIntegrationAuthorizationResult(
+            azures=self.azures,
+            environment=self.environment,
+            gcps=self.gcps,
+            id=self.id,
+            provider_integration_id=self.provider_integration_id)
+
+
+def get_provider_integration_authorization(environment: Optional[Union['GetProviderIntegrationAuthorizationEnvironmentArgs', 'GetProviderIntegrationAuthorizationEnvironmentArgsDict']] = None,
+                                           id: Optional[_builtins.str] = None,
+                                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetProviderIntegrationAuthorizationResult:
+    """
+    Use this data source to access information about an existing resource.
+
+    :param Union['GetProviderIntegrationAuthorizationEnvironmentArgs', 'GetProviderIntegrationAuthorizationEnvironmentArgsDict'] environment: (Required Configuration Block) supports the following:
+    :param _builtins.str id: The ID of the Provider Integration Authorization, for example, `cspi-4xg0q`.
+    """
+    __args__ = dict()
+    __args__['environment'] = environment
+    __args__['id'] = id
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('confluentcloud:index/getProviderIntegrationAuthorization:getProviderIntegrationAuthorization', __args__, opts=opts, typ=GetProviderIntegrationAuthorizationResult).value
+
+    return AwaitableGetProviderIntegrationAuthorizationResult(
+        azures=pulumi.get(__ret__, 'azures'),
+        environment=pulumi.get(__ret__, 'environment'),
+        gcps=pulumi.get(__ret__, 'gcps'),
+        id=pulumi.get(__ret__, 'id'),
+        provider_integration_id=pulumi.get(__ret__, 'provider_integration_id'))
+def get_provider_integration_authorization_output(environment: Optional[pulumi.Input[Union['GetProviderIntegrationAuthorizationEnvironmentArgs', 'GetProviderIntegrationAuthorizationEnvironmentArgsDict']]] = None,
+                                                  id: Optional[pulumi.Input[_builtins.str]] = None,
+                                                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetProviderIntegrationAuthorizationResult]:
+    """
+    Use this data source to access information about an existing resource.
+
+    :param Union['GetProviderIntegrationAuthorizationEnvironmentArgs', 'GetProviderIntegrationAuthorizationEnvironmentArgsDict'] environment: (Required Configuration Block) supports the following:
+    :param _builtins.str id: The ID of the Provider Integration Authorization, for example, `cspi-4xg0q`.
+    """
+    __args__ = dict()
+    __args__['environment'] = environment
+    __args__['id'] = id
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('confluentcloud:index/getProviderIntegrationAuthorization:getProviderIntegrationAuthorization', __args__, opts=opts, typ=GetProviderIntegrationAuthorizationResult)
+    return __ret__.apply(lambda __response__: GetProviderIntegrationAuthorizationResult(
+        azures=pulumi.get(__response__, 'azures'),
+        environment=pulumi.get(__response__, 'environment'),
+        gcps=pulumi.get(__response__, 'gcps'),
+        id=pulumi.get(__response__, 'id'),
+        provider_integration_id=pulumi.get(__response__, 'provider_integration_id')))