pulumi-confluentcloud 2.42.0__py3-none-any.whl → 2.54.0a1766503424__py3-none-any.whl

pulumi_confluentcloud/api_key.py

@@ -224,6 +224,98 @@ 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
         import pulumi
@@ -333,6 +425,98 @@ 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
         import pulumi

pulumi_confluentcloud/catalog_entity_attributes.py

@@ -333,6 +333,30 @@ class CatalogEntityAttributes(pulumi.CustomResource):
         ```
         > **Note:** We also support `schema_registry_rest_endpoint` instead of `catalog_rest_endpoint` for the time being.
 
+        ## Import
+
+        You can import a Catalog Entity Attributes resource by using the Schema Registry Cluster ID, Entity name in the format `<Schema Registry Cluster ID>/<Entity Type>/<Entity Name>/<Comma-Delimited-Attributes>`, for example:
+
+        Option #1: Manage multiple Catalog Entity Attributes in the same Pulumi Stack
+
+        $ export IMPORT_SCHEMA_REGISTRY_API_KEY="<schema_registry_api_key>"
+
+        $ export IMPORT_SCHEMA_REGISTRY_API_SECRET="<schema_registry_api_secret>"
+
+        $ export IMPORT_SCHEMA_REGISTRY_REST_ENDPOINT="<schema_registry_rest_endpoint>"
+
+        ```sh
+        $ pulumi import confluentcloud:index/catalogEntityAttributes:CatalogEntityAttributes environment lsrc-abc123/cf_environment/env-abc123/owner,description,ownerEmail
+        ```
+
+        Option #2: Manage a single Catalog Entity Attributes in the same Pulumi Stack
+
+        ```sh
+        $ pulumi import confluentcloud:index/catalogEntityAttributes:CatalogEntityAttributes environment lsrc-abc123/cf_environment/env-abc123/owner,description,ownerEmail
+        ```
+
+        !> **Warning:** Do not forget to delete terminal command history afterwards for security purposes.
+
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] attributes: The attributes.
@@ -451,6 +475,30 @@ class CatalogEntityAttributes(pulumi.CustomResource):
         ```
         > **Note:** We also support `schema_registry_rest_endpoint` instead of `catalog_rest_endpoint` for the time being.
 
+        ## Import
+
+        You can import a Catalog Entity Attributes resource by using the Schema Registry Cluster ID, Entity name in the format `<Schema Registry Cluster ID>/<Entity Type>/<Entity Name>/<Comma-Delimited-Attributes>`, for example:
+
+        Option #1: Manage multiple Catalog Entity Attributes in the same Pulumi Stack
+
+        $ export IMPORT_SCHEMA_REGISTRY_API_KEY="<schema_registry_api_key>"
+
+        $ export IMPORT_SCHEMA_REGISTRY_API_SECRET="<schema_registry_api_secret>"
+
+        $ export IMPORT_SCHEMA_REGISTRY_REST_ENDPOINT="<schema_registry_rest_endpoint>"
+
+        ```sh
+        $ pulumi import confluentcloud:index/catalogEntityAttributes:CatalogEntityAttributes environment lsrc-abc123/cf_environment/env-abc123/owner,description,ownerEmail
+        ```
+
+        Option #2: Manage a single Catalog Entity Attributes in the same Pulumi Stack
+
+        ```sh
+        $ pulumi import confluentcloud:index/catalogEntityAttributes:CatalogEntityAttributes environment lsrc-abc123/cf_environment/env-abc123/owner,description,ownerEmail
+        ```
+
+        !> **Warning:** Do not forget to delete terminal command history afterwards for security purposes.
+
         :param str resource_name: The name of the resource.
         :param CatalogEntityAttributesArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.

pulumi_confluentcloud/dns_forwarder.py

@@ -246,6 +246,32 @@ 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:
@@ -306,6 +332,32 @@ 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")