pulumi-kafka 3.11.0a1753397760__tar.gz → 3.12.0a1753509641__tar.gz

{pulumi_kafka-3.11.0a1753397760 → pulumi_kafka-3.12.0a1753509641}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_kafka
-Version: 3.11.0a1753397760
+Version: 3.12.0a1753509641
 Summary: A Pulumi package for creating and managing Kafka.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_kafka-3.11.0a1753397760 → pulumi_kafka-3.12.0a1753509641}/pulumi_kafka/__init__.py

@@ -8,10 +8,12 @@ import typing
 # Export this package's modules as members:
 from .acl import *
 from .get_topic import *
+from .get_topics import *
 from .provider import *
 from .quota import *
 from .topic import *
 from .user_scram_credential import *
+from . import outputs
 
 # Make subpackages available:
 if typing.TYPE_CHECKING:

{pulumi_kafka-3.11.0a1753397760 → pulumi_kafka-3.12.0a1753509641}/pulumi_kafka/acl.py

@@ -217,7 +217,121 @@ class Acl(pulumi.CustomResource):
                  resource_pattern_type_filter: Optional[pulumi.Input[_builtins.str]] = None,
                  __props__=None):
         """
-        Create a Acl resource with the given unique name, props, and options.
+        The `Acl` resource manages Apache Kafka Access Control Lists (ACLs). ACLs control access to Kafka resources like topics, consumer groups, and clusters by defining which principals (users or services) can perform specific operations on these resources.
+
+        ## Example Usage
+
+        ### Allow Producer Access to Topic
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        producer = kafka.Acl("producer",
+            acl_resource_name="orders",
+            acl_resource_type="Topic",
+            acl_principal="User:producer-service",
+            acl_host="*",
+            acl_operation="Write",
+            acl_permission_type="Allow")
+        # Also grant describe permission for producers
+        producer_describe = kafka.Acl("producer_describe",
+            acl_resource_name="orders",
+            acl_resource_type="Topic",
+            acl_principal="User:producer-service",
+            acl_host="*",
+            acl_operation="Describe",
+            acl_permission_type="Allow")
+        ```
+
+        ### Allow Consumer Group Access
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Allow read access to topic
+        consumer_read = kafka.Acl("consumer_read",
+            acl_resource_name="orders",
+            acl_resource_type="Topic",
+            acl_principal="User:consumer-service",
+            acl_host="*",
+            acl_operation="Read",
+            acl_permission_type="Allow")
+        # Allow access to consumer group
+        consumer_group = kafka.Acl("consumer_group",
+            acl_resource_name="order-processors",
+            acl_resource_type="Group",
+            acl_principal="User:consumer-service",
+            acl_host="*",
+            acl_operation="Read",
+            acl_permission_type="Allow")
+        ```
+
+        ### Prefix-Based Access Control
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Grant access to all topics with prefix "logs-"
+        logs_access = kafka.Acl("logs_access",
+            acl_resource_name="logs-",
+            acl_resource_type="Topic",
+            resource_pattern_type_filter="Prefixed",
+            acl_principal="User:log-aggregator",
+            acl_host="*",
+            acl_operation="Read",
+            acl_permission_type="Allow")
+        ```
+
+        ### Admin User with Full Access
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Grant cluster-level admin access
+        admin_cluster = kafka.Acl("admin_cluster",
+            acl_resource_name="kafka-cluster",
+            acl_resource_type="Cluster",
+            acl_principal="User:admin",
+            acl_host="*",
+            acl_operation="All",
+            acl_permission_type="Allow")
+        ```
+
+        ## Common ACL Patterns
+
+        ### Producer ACLs
+        Producers typically need:
+        - `Write` and `Describe` on topics
+        - `Write` on `TransactionalID` (for transactional producers)
+        - `IdempotentWrite` on `Cluster` (for idempotent producers)
+
+        ### Consumer ACLs
+        Consumers typically need:
+        - `Read` on topics
+        - `Read` on consumer groups
+        - `Describe` on topics (optional, for metadata)
+
+        ### Admin ACLs
+        Administrators typically need:
+        - `All` on `Cluster`
+        - Or specific operations like `Alter`, `AlterConfigs`, `Create`, `Delete`
+
+        > **Warning:** Be cautious with `Deny` ACLs as they take precedence over `Allow` ACLs. A deny rule will block access even if an allow rule exists.
+
+        ## Import
+
+        Kafka ACLs can be imported using a pipe-delimited string containing all ACL properties:
+
+        Format: ${acl_principal}|${acl_host}|${acl_operation}|${acl_permission_type}|${resource_type}|${resource_name}|${resource_pattern_type_filter}
+
+        ```sh
+        $ pulumi import kafka:index/acl:Acl example 'User:producer|*|Write|Allow|Topic|orders|Literal'
+        ```
+
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[_builtins.str] acl_resource_name: The name of the resource
@@ -229,7 +343,121 @@ class Acl(pulumi.CustomResource):
                  args: AclArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
-        Create a Acl resource with the given unique name, props, and options.
+        The `Acl` resource manages Apache Kafka Access Control Lists (ACLs). ACLs control access to Kafka resources like topics, consumer groups, and clusters by defining which principals (users or services) can perform specific operations on these resources.
+
+        ## Example Usage
+
+        ### Allow Producer Access to Topic
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        producer = kafka.Acl("producer",
+            acl_resource_name="orders",
+            acl_resource_type="Topic",
+            acl_principal="User:producer-service",
+            acl_host="*",
+            acl_operation="Write",
+            acl_permission_type="Allow")
+        # Also grant describe permission for producers
+        producer_describe = kafka.Acl("producer_describe",
+            acl_resource_name="orders",
+            acl_resource_type="Topic",
+            acl_principal="User:producer-service",
+            acl_host="*",
+            acl_operation="Describe",
+            acl_permission_type="Allow")
+        ```
+
+        ### Allow Consumer Group Access
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Allow read access to topic
+        consumer_read = kafka.Acl("consumer_read",
+            acl_resource_name="orders",
+            acl_resource_type="Topic",
+            acl_principal="User:consumer-service",
+            acl_host="*",
+            acl_operation="Read",
+            acl_permission_type="Allow")
+        # Allow access to consumer group
+        consumer_group = kafka.Acl("consumer_group",
+            acl_resource_name="order-processors",
+            acl_resource_type="Group",
+            acl_principal="User:consumer-service",
+            acl_host="*",
+            acl_operation="Read",
+            acl_permission_type="Allow")
+        ```
+
+        ### Prefix-Based Access Control
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Grant access to all topics with prefix "logs-"
+        logs_access = kafka.Acl("logs_access",
+            acl_resource_name="logs-",
+            acl_resource_type="Topic",
+            resource_pattern_type_filter="Prefixed",
+            acl_principal="User:log-aggregator",
+            acl_host="*",
+            acl_operation="Read",
+            acl_permission_type="Allow")
+        ```
+
+        ### Admin User with Full Access
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Grant cluster-level admin access
+        admin_cluster = kafka.Acl("admin_cluster",
+            acl_resource_name="kafka-cluster",
+            acl_resource_type="Cluster",
+            acl_principal="User:admin",
+            acl_host="*",
+            acl_operation="All",
+            acl_permission_type="Allow")
+        ```
+
+        ## Common ACL Patterns
+
+        ### Producer ACLs
+        Producers typically need:
+        - `Write` and `Describe` on topics
+        - `Write` on `TransactionalID` (for transactional producers)
+        - `IdempotentWrite` on `Cluster` (for idempotent producers)
+
+        ### Consumer ACLs
+        Consumers typically need:
+        - `Read` on topics
+        - `Read` on consumer groups
+        - `Describe` on topics (optional, for metadata)
+
+        ### Admin ACLs
+        Administrators typically need:
+        - `All` on `Cluster`
+        - Or specific operations like `Alter`, `AlterConfigs`, `Create`, `Delete`
+
+        > **Warning:** Be cautious with `Deny` ACLs as they take precedence over `Allow` ACLs. A deny rule will block access even if an allow rule exists.
+
+        ## Import
+
+        Kafka ACLs can be imported using a pipe-delimited string containing all ACL properties:
+
+        Format: ${acl_principal}|${acl_host}|${acl_operation}|${acl_permission_type}|${resource_type}|${resource_name}|${resource_pattern_type_filter}
+
+        ```sh
+        $ pulumi import kafka:index/acl:Acl example 'User:producer|*|Write|Allow|Topic|orders|Literal'
+        ```
+
         :param str resource_name: The name of the resource.
         :param AclArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.

pulumi_kafka-3.12.0a1753509641/pulumi_kafka/get_topics.py

@@ -0,0 +1,85 @@
+# 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
+
+__all__ = [
+    'GetTopicsResult',
+    'AwaitableGetTopicsResult',
+    'get_topics',
+    'get_topics_output',
+]
+
+@pulumi.output_type
+class GetTopicsResult:
+    """
+    A collection of values returned by getTopics.
+    """
+    def __init__(__self__, id=None, lists=None):
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if lists and not isinstance(lists, list):
+            raise TypeError("Expected argument 'lists' to be a list")
+        pulumi.set(__self__, "lists", lists)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter
+    def lists(self) -> Sequence['outputs.GetTopicsListResult']:
+        """
+        A list containing all the topics.
+        """
+        return pulumi.get(self, "lists")
+
+
+class AwaitableGetTopicsResult(GetTopicsResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetTopicsResult(
+            id=self.id,
+            lists=self.lists)
+
+
+def get_topics(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetTopicsResult:
+    """
+    Use this data source to access information about an existing resource.
+    """
+    __args__ = dict()
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('kafka:index:getTopics', __args__, opts=opts, typ=GetTopicsResult).value
+
+    return AwaitableGetTopicsResult(
+        id=pulumi.get(__ret__, 'id'),
+        lists=pulumi.get(__ret__, 'lists'))
+def get_topics_output(opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetTopicsResult]:
+    """
+    Use this data source to access information about an existing resource.
+    """
+    __args__ = dict()
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('kafka:index:getTopics', __args__, opts=opts, typ=GetTopicsResult)
+    return __ret__.apply(lambda __response__: GetTopicsResult(
+        id=pulumi.get(__response__, 'id'),
+        lists=pulumi.get(__response__, 'lists')))

pulumi_kafka-3.12.0a1753509641/pulumi_kafka/outputs.py

@@ -0,0 +1,71 @@
+# 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
+
+__all__ = [
+    'GetTopicsListResult',
+]
+
+@pulumi.output_type
+class GetTopicsListResult(dict):
+    def __init__(__self__, *,
+                 config: Mapping[str, _builtins.str],
+                 partitions: _builtins.int,
+                 replication_factor: _builtins.int,
+                 topic_name: _builtins.str):
+        """
+        :param Mapping[str, _builtins.str] config: A map of string k/v attributes.
+        :param _builtins.int partitions: Number of partitions.
+        :param _builtins.int replication_factor: Number of replicas.
+        :param _builtins.str topic_name: The name of the topic.
+        """
+        pulumi.set(__self__, "config", config)
+        pulumi.set(__self__, "partitions", partitions)
+        pulumi.set(__self__, "replication_factor", replication_factor)
+        pulumi.set(__self__, "topic_name", topic_name)
+
+    @_builtins.property
+    @pulumi.getter
+    def config(self) -> Mapping[str, _builtins.str]:
+        """
+        A map of string k/v attributes.
+        """
+        return pulumi.get(self, "config")
+
+    @_builtins.property
+    @pulumi.getter
+    def partitions(self) -> _builtins.int:
+        """
+        Number of partitions.
+        """
+        return pulumi.get(self, "partitions")
+
+    @_builtins.property
+    @pulumi.getter(name="replicationFactor")
+    def replication_factor(self) -> _builtins.int:
+        """
+        Number of replicas.
+        """
+        return pulumi.get(self, "replication_factor")
+
+    @_builtins.property
+    @pulumi.getter(name="topicName")
+    def topic_name(self) -> _builtins.str:
+        """
+        The name of the topic.
+        """
+        return pulumi.get(self, "topic_name")
+
+

{pulumi_kafka-3.11.0a1753397760 → pulumi_kafka-3.12.0a1753509641}/pulumi_kafka/pulumi-plugin.json

@@ -1,5 +1,5 @@
 {
   "resource": true,
   "name": "kafka",
-  "version": "3.11.0-alpha.1753397760"
+  "version": "3.12.0-alpha.1753509641"
 }

{pulumi_kafka-3.11.0a1753397760 → pulumi_kafka-3.12.0a1753509641}/pulumi_kafka/quota.py

@@ -138,7 +138,128 @@ class Quota(pulumi.CustomResource):
                  entity_type: Optional[pulumi.Input[_builtins.str]] = None,
                  __props__=None):
         """
-        Create a Quota resource with the given unique name, props, and options.
+        The `Quota` resource manages Kafka quotas, which are used to limit resource usage and prevent any single client from monopolizing broker resources. Quotas can be applied to clients, users, or IP addresses to control bandwidth and request rates.
+
+        ## Example Usage
+
+        ### Client ID Quota
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Limit a specific client's bandwidth
+        mobile_app = kafka.Quota("mobile_app",
+            entity_name="mobile-app-v1",
+            entity_type="client-id",
+            config={
+                "consumer_byte_rate": "5000000",
+                "producer_byte_rate": "2500000",
+                "request_percentage": "200",
+            })
+        ```
+
+        ### User Quota
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Set quotas for a specific user
+        service_account = kafka.Quota("service_account",
+            entity_name="payment-service",
+            entity_type="user",
+            config={
+                "consumer_byte_rate": "10000000",
+                "producer_byte_rate": "10000000",
+                "request_percentage": "400",
+            })
+        ```
+
+        ### Default User Quota
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Set default quotas for all users (when entity_name is omitted)
+        default_user = kafka.Quota("default_user",
+            entity_type="user",
+            config={
+                "consumer_byte_rate": "2000000",
+                "producer_byte_rate": "1000000",
+                "request_percentage": "100",
+            })
+        ```
+
+        ### IP Address Quota
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Rate limit connections from a specific IP
+        external_ip = kafka.Quota("external_ip",
+            entity_name="203.0.113.0",
+            entity_type="ip",
+            config={
+                "connection_creation_rate": "10",
+            })
+        ```
+
+        ## Quota Configuration Options
+
+        ### Bandwidth Quotas
+        - `producer_byte_rate` - The maximum bytes per second that can be produced by the entity
+        - `consumer_byte_rate` - The maximum bytes per second that can be consumed by the entity
+
+        ### Request Rate Quotas
+        - `request_percentage` - The percentage of CPU time on each broker that the entity can use for requests. Values > 100% indicate multiple CPUs (e.g., 200% = 2 CPUs)
+
+        ### Connection Quotas (IP-based only)
+        - `connection_creation_rate` - The maximum rate of new connections per second from the IP address
+
+        ## Quota Precedence
+
+        When multiple quotas apply to a request, Kafka uses the most specific quota:
+
+        1. `/config/users/<user>/clients/<client-id>` (most specific)
+        2. `/config/users/<user>/clients/<default>`
+        3. `/config/users/<user>`
+        4. `/config/users/<default>/clients/<client-id>`
+        5. `/config/users/<default>/clients/<default>`
+        6. `/config/users/<default>` (least specific)
+
+        ## Best Practices
+
+        1. **Start with Conservative Defaults**: Set reasonable default quotas for all users/clients and then create specific quotas for services that need higher limits.
+
+        2. **Monitor Quota Usage**: Use Kafka metrics to monitor quota utilization and adjust as needed. Look for throttling metrics to identify when quotas are being hit.
+
+        3. **Use Request Percentage Carefully**: The `request_percentage` quota affects CPU usage. Values over 100% mean the client can use more than one CPU core.
+
+        4. **Plan for Growth**: Set quotas with some headroom to accommodate traffic growth, but not so high that a misbehaving client can impact the cluster.
+
+        5. **Different Quotas for Different Environments**: Use stricter quotas in development/staging environments compared to production.
+
+        > **Note:** Quotas are applied immediately but may take a few seconds to propagate across all brokers.
+
+        ## Import
+
+        Kafka quotas can be imported using the entity type and name:
+
+        For named entities
+
+        ```sh
+        $ pulumi import kafka:index/quota:Quota example client-id:my-client
+        ```
+
+        For default quotas (no entity name)
+
+        ```sh
+        $ pulumi import kafka:index/quota:Quota default_user user:
+        ```
+
         :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]]] config: A map of string k/v properties.
@@ -152,7 +273,128 @@ class Quota(pulumi.CustomResource):
                  args: QuotaArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
-        Create a Quota resource with the given unique name, props, and options.
+        The `Quota` resource manages Kafka quotas, which are used to limit resource usage and prevent any single client from monopolizing broker resources. Quotas can be applied to clients, users, or IP addresses to control bandwidth and request rates.
+
+        ## Example Usage
+
+        ### Client ID Quota
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Limit a specific client's bandwidth
+        mobile_app = kafka.Quota("mobile_app",
+            entity_name="mobile-app-v1",
+            entity_type="client-id",
+            config={
+                "consumer_byte_rate": "5000000",
+                "producer_byte_rate": "2500000",
+                "request_percentage": "200",
+            })
+        ```
+
+        ### User Quota
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Set quotas for a specific user
+        service_account = kafka.Quota("service_account",
+            entity_name="payment-service",
+            entity_type="user",
+            config={
+                "consumer_byte_rate": "10000000",
+                "producer_byte_rate": "10000000",
+                "request_percentage": "400",
+            })
+        ```
+
+        ### Default User Quota
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Set default quotas for all users (when entity_name is omitted)
+        default_user = kafka.Quota("default_user",
+            entity_type="user",
+            config={
+                "consumer_byte_rate": "2000000",
+                "producer_byte_rate": "1000000",
+                "request_percentage": "100",
+            })
+        ```
+
+        ### IP Address Quota
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        # Rate limit connections from a specific IP
+        external_ip = kafka.Quota("external_ip",
+            entity_name="203.0.113.0",
+            entity_type="ip",
+            config={
+                "connection_creation_rate": "10",
+            })
+        ```
+
+        ## Quota Configuration Options
+
+        ### Bandwidth Quotas
+        - `producer_byte_rate` - The maximum bytes per second that can be produced by the entity
+        - `consumer_byte_rate` - The maximum bytes per second that can be consumed by the entity
+
+        ### Request Rate Quotas
+        - `request_percentage` - The percentage of CPU time on each broker that the entity can use for requests. Values > 100% indicate multiple CPUs (e.g., 200% = 2 CPUs)
+
+        ### Connection Quotas (IP-based only)
+        - `connection_creation_rate` - The maximum rate of new connections per second from the IP address
+
+        ## Quota Precedence
+
+        When multiple quotas apply to a request, Kafka uses the most specific quota:
+
+        1. `/config/users/<user>/clients/<client-id>` (most specific)
+        2. `/config/users/<user>/clients/<default>`
+        3. `/config/users/<user>`
+        4. `/config/users/<default>/clients/<client-id>`
+        5. `/config/users/<default>/clients/<default>`
+        6. `/config/users/<default>` (least specific)
+
+        ## Best Practices
+
+        1. **Start with Conservative Defaults**: Set reasonable default quotas for all users/clients and then create specific quotas for services that need higher limits.
+
+        2. **Monitor Quota Usage**: Use Kafka metrics to monitor quota utilization and adjust as needed. Look for throttling metrics to identify when quotas are being hit.
+
+        3. **Use Request Percentage Carefully**: The `request_percentage` quota affects CPU usage. Values over 100% mean the client can use more than one CPU core.
+
+        4. **Plan for Growth**: Set quotas with some headroom to accommodate traffic growth, but not so high that a misbehaving client can impact the cluster.
+
+        5. **Different Quotas for Different Environments**: Use stricter quotas in development/staging environments compared to production.
+
+        > **Note:** Quotas are applied immediately but may take a few seconds to propagate across all brokers.
+
+        ## Import
+
+        Kafka quotas can be imported using the entity type and name:
+
+        For named entities
+
+        ```sh
+        $ pulumi import kafka:index/quota:Quota example client-id:my-client
+        ```
+
+        For default quotas (no entity name)
+
+        ```sh
+        $ pulumi import kafka:index/quota:Quota default_user user:
+        ```
+
         :param str resource_name: The name of the resource.
         :param QuotaArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.

{pulumi_kafka-3.11.0a1753397760 → pulumi_kafka-3.12.0a1753509641}/pulumi_kafka/topic.py

@@ -170,7 +170,118 @@ class Topic(pulumi.CustomResource):
                  replication_factor: Optional[pulumi.Input[_builtins.int]] = None,
                  __props__=None):
         """
-        Create a Topic resource with the given unique name, props, and options.
+        The `Topic` resource manages Apache Kafka topics, including their partition count, replication factor, and various configuration parameters. This resource supports non-destructive partition count increases.
+
+        ## Example Usage
+
+        ### Basic Topic
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        example = kafka.Topic("example",
+            name="example-topic",
+            replication_factor=3,
+            partitions=10)
+        ```
+
+        ### Topic with Common Configurations
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        logs = kafka.Topic("logs",
+            name="application-logs",
+            replication_factor=3,
+            partitions=50,
+            config={
+                "retention.ms": "604800000",
+                "segment.ms": "86400000",
+                "cleanup.policy": "delete",
+                "compression.type": "gzip",
+            })
+        ```
+
+        ### Compacted Topic for Event Sourcing
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        events = kafka.Topic("events",
+            name="user-events",
+            replication_factor=3,
+            partitions=100,
+            config={
+                "cleanup.policy": "compact",
+                "retention.ms": "-1",
+                "min.compaction.lag.ms": "3600000",
+                "delete.retention.ms": "86400000",
+                "compression.type": "lz4",
+                "segment.bytes": "1073741824",
+            })
+        ```
+
+        ### High-Throughput Topic
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        metrics = kafka.Topic("metrics",
+            name="system-metrics",
+            replication_factor=2,
+            partitions=200,
+            config={
+                "retention.ms": "86400000",
+                "segment.ms": "3600000",
+                "compression.type": "lz4",
+                "max.message.bytes": "1048576",
+                "min.insync.replicas": "2",
+                "unclean.leader.election.enable": "false",
+            })
+        ```
+
+        ## Configuration Parameters
+
+        The `config` map supports all Kafka topic-level configurations. Common configurations include:
+
+        ### Retention Settings
+        - `retention.ms` - How long to retain messages (in milliseconds). Default: 604800000 (7 days)
+        - `retention.bytes` - Maximum size of the log before deleting old segments. Default: -1 (no limit)
+        - `segment.ms` - Time after which a log segment should be rotated. Default: 604800000 (7 days)
+        - `segment.bytes` - Maximum size of a single log segment file. Default: 1073741824 (1GB)
+
+        ### Cleanup and Compaction
+        - `cleanup.policy` - Either "delete" or "compact" or both "compact,delete". Default: "delete"
+        - `min.compaction.lag.ms` - Minimum time a message will remain uncompacted. Default: 0
+        - `delete.retention.ms` - How long to retain delete tombstone markers for compacted topics. Default: 86400000 (1 day)
+
+        ### Compression
+        - `compression.type` - Compression codec: "uncompressed", "zstd", "lz4", "snappy", "gzip", "producer". Default: "producer"
+
+        ### Replication and Durability
+        - `min.insync.replicas` - Minimum number of replicas that must acknowledge a write. Default: 1
+        - `unclean.leader.election.enable` - Whether to allow replicas not in ISR to be elected leader. Default: false
+
+        ### Message Size
+        - `max.message.bytes` - Maximum size of a message. Default: 1048588 (~1MB)
+        - `message.timestamp.type` - Whether to use CreateTime or LogAppendTime. Default: "CreateTime"
+
+        For a complete list of configurations, refer to the [Kafka documentation](https://kafka.apache.org/documentation/#topicconfigs).
+
+        > **Note:** Increasing the partition count is supported without recreating the topic. However, decreasing partitions requires topic recreation.
+
+        ## Import
+
+        Existing Kafka topics can be imported using the topic name:
+
+        ```sh
+        $ pulumi import kafka:index/topic:Topic example example-topic
+        ```
+
         :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]]] config: A map of string k/v attributes.
@@ -185,7 +296,118 @@ class Topic(pulumi.CustomResource):
                  args: TopicArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
-        Create a Topic resource with the given unique name, props, and options.
+        The `Topic` resource manages Apache Kafka topics, including their partition count, replication factor, and various configuration parameters. This resource supports non-destructive partition count increases.
+
+        ## Example Usage
+
+        ### Basic Topic
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        example = kafka.Topic("example",
+            name="example-topic",
+            replication_factor=3,
+            partitions=10)
+        ```
+
+        ### Topic with Common Configurations
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        logs = kafka.Topic("logs",
+            name="application-logs",
+            replication_factor=3,
+            partitions=50,
+            config={
+                "retention.ms": "604800000",
+                "segment.ms": "86400000",
+                "cleanup.policy": "delete",
+                "compression.type": "gzip",
+            })
+        ```
+
+        ### Compacted Topic for Event Sourcing
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        events = kafka.Topic("events",
+            name="user-events",
+            replication_factor=3,
+            partitions=100,
+            config={
+                "cleanup.policy": "compact",
+                "retention.ms": "-1",
+                "min.compaction.lag.ms": "3600000",
+                "delete.retention.ms": "86400000",
+                "compression.type": "lz4",
+                "segment.bytes": "1073741824",
+            })
+        ```
+
+        ### High-Throughput Topic
+
+        ```python
+        import pulumi
+        import pulumi_kafka as kafka
+
+        metrics = kafka.Topic("metrics",
+            name="system-metrics",
+            replication_factor=2,
+            partitions=200,
+            config={
+                "retention.ms": "86400000",
+                "segment.ms": "3600000",
+                "compression.type": "lz4",
+                "max.message.bytes": "1048576",
+                "min.insync.replicas": "2",
+                "unclean.leader.election.enable": "false",
+            })
+        ```
+
+        ## Configuration Parameters
+
+        The `config` map supports all Kafka topic-level configurations. Common configurations include:
+
+        ### Retention Settings
+        - `retention.ms` - How long to retain messages (in milliseconds). Default: 604800000 (7 days)
+        - `retention.bytes` - Maximum size of the log before deleting old segments. Default: -1 (no limit)
+        - `segment.ms` - Time after which a log segment should be rotated. Default: 604800000 (7 days)
+        - `segment.bytes` - Maximum size of a single log segment file. Default: 1073741824 (1GB)
+
+        ### Cleanup and Compaction
+        - `cleanup.policy` - Either "delete" or "compact" or both "compact,delete". Default: "delete"
+        - `min.compaction.lag.ms` - Minimum time a message will remain uncompacted. Default: 0
+        - `delete.retention.ms` - How long to retain delete tombstone markers for compacted topics. Default: 86400000 (1 day)
+
+        ### Compression
+        - `compression.type` - Compression codec: "uncompressed", "zstd", "lz4", "snappy", "gzip", "producer". Default: "producer"
+
+        ### Replication and Durability
+        - `min.insync.replicas` - Minimum number of replicas that must acknowledge a write. Default: 1
+        - `unclean.leader.election.enable` - Whether to allow replicas not in ISR to be elected leader. Default: false
+
+        ### Message Size
+        - `max.message.bytes` - Maximum size of a message. Default: 1048588 (~1MB)
+        - `message.timestamp.type` - Whether to use CreateTime or LogAppendTime. Default: "CreateTime"
+
+        For a complete list of configurations, refer to the [Kafka documentation](https://kafka.apache.org/documentation/#topicconfigs).
+
+        > **Note:** Increasing the partition count is supported without recreating the topic. However, decreasing partitions requires topic recreation.
+
+        ## Import
+
+        Existing Kafka topics can be imported using the topic name:
+
+        ```sh
+        $ pulumi import kafka:index/topic:Topic example example-topic
+        ```
+
         :param str resource_name: The name of the resource.
         :param TopicArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.

{pulumi_kafka-3.11.0a1753397760 → pulumi_kafka-3.12.0a1753509641}/pulumi_kafka/user_scram_credential.py

@@ -19,35 +19,28 @@ __all__ = ['UserScramCredentialArgs', 'UserScramCredential']
 @pulumi.input_type
 class UserScramCredentialArgs:
     def __init__(__self__, *,
-                 password: pulumi.Input[_builtins.str],
                  scram_mechanism: pulumi.Input[_builtins.str],
                  username: pulumi.Input[_builtins.str],
+                 password: Optional[pulumi.Input[_builtins.str]] = None,
+                 password_wo_version: Optional[pulumi.Input[_builtins.str]] = None,
                  scram_iterations: Optional[pulumi.Input[_builtins.int]] = None):
         """
         The set of arguments for constructing a UserScramCredential resource.
-        :param pulumi.Input[_builtins.str] password: The password of the credential
         :param pulumi.Input[_builtins.str] scram_mechanism: The SCRAM mechanism used to generate the credential (SCRAM-SHA-256, SCRAM-SHA-512)
         :param pulumi.Input[_builtins.str] username: The name of the credential
+        :param pulumi.Input[_builtins.str] password: The password of the credential (deprecated, use password_wo instead)
+        :param pulumi.Input[_builtins.str] password_wo_version: Version identifier for the write-only password to track changes
         :param pulumi.Input[_builtins.int] scram_iterations: The number of SCRAM iterations used when generating the credential
         """
-        pulumi.set(__self__, "password", password)
         pulumi.set(__self__, "scram_mechanism", scram_mechanism)
         pulumi.set(__self__, "username", username)
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if password_wo_version is not None:
+            pulumi.set(__self__, "password_wo_version", password_wo_version)
         if scram_iterations is not None:
             pulumi.set(__self__, "scram_iterations", scram_iterations)
 
-    @_builtins.property
-    @pulumi.getter
-    def password(self) -> pulumi.Input[_builtins.str]:
-        """
-        The password of the credential
-        """
-        return pulumi.get(self, "password")
-
-    @password.setter
-    def password(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "password", value)
-
     @_builtins.property
     @pulumi.getter(name="scramMechanism")
     def scram_mechanism(self) -> pulumi.Input[_builtins.str]:
@@ -72,6 +65,30 @@ class UserScramCredentialArgs:
     def username(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "username", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The password of the credential (deprecated, use password_wo instead)
+        """
+        return pulumi.get(self, "password")
+
+    @password.setter
+    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "password", value)
+
+    @_builtins.property
+    @pulumi.getter(name="passwordWoVersion")
+    def password_wo_version(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Version identifier for the write-only password to track changes
+        """
+        return pulumi.get(self, "password_wo_version")
+
+    @password_wo_version.setter
+    def password_wo_version(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "password_wo_version", value)
+
     @_builtins.property
     @pulumi.getter(name="scramIterations")
     def scram_iterations(self) -> Optional[pulumi.Input[_builtins.int]]:
@@ -89,18 +106,22 @@ class UserScramCredentialArgs:
 class _UserScramCredentialState:
     def __init__(__self__, *,
                  password: Optional[pulumi.Input[_builtins.str]] = None,
+                 password_wo_version: Optional[pulumi.Input[_builtins.str]] = None,
                  scram_iterations: Optional[pulumi.Input[_builtins.int]] = None,
                  scram_mechanism: Optional[pulumi.Input[_builtins.str]] = None,
                  username: Optional[pulumi.Input[_builtins.str]] = None):
         """
         Input properties used for looking up and filtering UserScramCredential resources.
-        :param pulumi.Input[_builtins.str] password: The password of the credential
+        :param pulumi.Input[_builtins.str] password: The password of the credential (deprecated, use password_wo instead)
+        :param pulumi.Input[_builtins.str] password_wo_version: Version identifier for the write-only password to track changes
         :param pulumi.Input[_builtins.int] scram_iterations: The number of SCRAM iterations used when generating the credential
         :param pulumi.Input[_builtins.str] scram_mechanism: The SCRAM mechanism used to generate the credential (SCRAM-SHA-256, SCRAM-SHA-512)
         :param pulumi.Input[_builtins.str] username: The name of the credential
         """
         if password is not None:
             pulumi.set(__self__, "password", password)
+        if password_wo_version is not None:
+            pulumi.set(__self__, "password_wo_version", password_wo_version)
         if scram_iterations is not None:
             pulumi.set(__self__, "scram_iterations", scram_iterations)
         if scram_mechanism is not None:
@@ -112,7 +133,7 @@ class _UserScramCredentialState:
     @pulumi.getter
     def password(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        The password of the credential
+        The password of the credential (deprecated, use password_wo instead)
         """
         return pulumi.get(self, "password")
 
@@ -120,6 +141,18 @@ class _UserScramCredentialState:
     def password(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "password", value)
 
+    @_builtins.property
+    @pulumi.getter(name="passwordWoVersion")
+    def password_wo_version(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Version identifier for the write-only password to track changes
+        """
+        return pulumi.get(self, "password_wo_version")
+
+    @password_wo_version.setter
+    def password_wo_version(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "password_wo_version", value)
+
     @_builtins.property
     @pulumi.getter(name="scramIterations")
     def scram_iterations(self) -> Optional[pulumi.Input[_builtins.int]]:
@@ -164,15 +197,24 @@ class UserScramCredential(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  password: Optional[pulumi.Input[_builtins.str]] = None,
+                 password_wo_version: Optional[pulumi.Input[_builtins.str]] = None,
                  scram_iterations: Optional[pulumi.Input[_builtins.int]] = None,
                  scram_mechanism: Optional[pulumi.Input[_builtins.str]] = None,
                  username: Optional[pulumi.Input[_builtins.str]] = None,
                  __props__=None):
         """
-        Create a UserScramCredential resource with the given unique name, props, and options.
+        ## Import
+
+        SCRAM credentials can be imported using the format `username|scram_mechanism|password`:
+
+        ```sh
+        $ pulumi import kafka:index/userScramCredential:UserScramCredential example 'my-user|SCRAM-SHA-256|my-password'
+        ```
+
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[_builtins.str] password: The password of the credential
+        :param pulumi.Input[_builtins.str] password: The password of the credential (deprecated, use password_wo instead)
+        :param pulumi.Input[_builtins.str] password_wo_version: Version identifier for the write-only password to track changes
         :param pulumi.Input[_builtins.int] scram_iterations: The number of SCRAM iterations used when generating the credential
         :param pulumi.Input[_builtins.str] scram_mechanism: The SCRAM mechanism used to generate the credential (SCRAM-SHA-256, SCRAM-SHA-512)
         :param pulumi.Input[_builtins.str] username: The name of the credential
@@ -184,7 +226,14 @@ class UserScramCredential(pulumi.CustomResource):
                  args: UserScramCredentialArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
-        Create a UserScramCredential resource with the given unique name, props, and options.
+        ## Import
+
+        SCRAM credentials can be imported using the format `username|scram_mechanism|password`:
+
+        ```sh
+        $ pulumi import kafka:index/userScramCredential:UserScramCredential example 'my-user|SCRAM-SHA-256|my-password'
+        ```
+
         :param str resource_name: The name of the resource.
         :param UserScramCredentialArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.
@@ -201,6 +250,7 @@ class UserScramCredential(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  password: Optional[pulumi.Input[_builtins.str]] = None,
+                 password_wo_version: Optional[pulumi.Input[_builtins.str]] = None,
                  scram_iterations: Optional[pulumi.Input[_builtins.int]] = None,
                  scram_mechanism: Optional[pulumi.Input[_builtins.str]] = None,
                  username: Optional[pulumi.Input[_builtins.str]] = None,
@@ -213,9 +263,8 @@ class UserScramCredential(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = UserScramCredentialArgs.__new__(UserScramCredentialArgs)
 
-            if password is None and not opts.urn:
-                raise TypeError("Missing required property 'password'")
             __props__.__dict__["password"] = None if password is None else pulumi.Output.secret(password)
+            __props__.__dict__["password_wo_version"] = password_wo_version
             __props__.__dict__["scram_iterations"] = scram_iterations
             if scram_mechanism is None and not opts.urn:
                 raise TypeError("Missing required property 'scram_mechanism'")
@@ -236,6 +285,7 @@ class UserScramCredential(pulumi.CustomResource):
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
             password: Optional[pulumi.Input[_builtins.str]] = None,
+            password_wo_version: Optional[pulumi.Input[_builtins.str]] = None,
             scram_iterations: Optional[pulumi.Input[_builtins.int]] = None,
             scram_mechanism: Optional[pulumi.Input[_builtins.str]] = None,
             username: Optional[pulumi.Input[_builtins.str]] = None) -> 'UserScramCredential':
@@ -246,7 +296,8 @@ class UserScramCredential(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[_builtins.str] password: The password of the credential
+        :param pulumi.Input[_builtins.str] password: The password of the credential (deprecated, use password_wo instead)
+        :param pulumi.Input[_builtins.str] password_wo_version: Version identifier for the write-only password to track changes
         :param pulumi.Input[_builtins.int] scram_iterations: The number of SCRAM iterations used when generating the credential
         :param pulumi.Input[_builtins.str] scram_mechanism: The SCRAM mechanism used to generate the credential (SCRAM-SHA-256, SCRAM-SHA-512)
         :param pulumi.Input[_builtins.str] username: The name of the credential
@@ -256,6 +307,7 @@ class UserScramCredential(pulumi.CustomResource):
         __props__ = _UserScramCredentialState.__new__(_UserScramCredentialState)
 
         __props__.__dict__["password"] = password
+        __props__.__dict__["password_wo_version"] = password_wo_version
         __props__.__dict__["scram_iterations"] = scram_iterations
         __props__.__dict__["scram_mechanism"] = scram_mechanism
         __props__.__dict__["username"] = username
@@ -263,12 +315,20 @@ class UserScramCredential(pulumi.CustomResource):
 
     @_builtins.property
     @pulumi.getter
-    def password(self) -> pulumi.Output[_builtins.str]:
+    def password(self) -> pulumi.Output[Optional[_builtins.str]]:
         """
-        The password of the credential
+        The password of the credential (deprecated, use password_wo instead)
         """
         return pulumi.get(self, "password")
 
+    @_builtins.property
+    @pulumi.getter(name="passwordWoVersion")
+    def password_wo_version(self) -> pulumi.Output[Optional[_builtins.str]]:
+        """
+        Version identifier for the write-only password to track changes
+        """
+        return pulumi.get(self, "password_wo_version")
+
     @_builtins.property
     @pulumi.getter(name="scramIterations")
     def scram_iterations(self) -> pulumi.Output[Optional[_builtins.int]]:

{pulumi_kafka-3.11.0a1753397760 → pulumi_kafka-3.12.0a1753509641}/pulumi_kafka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_kafka
-Version: 3.11.0a1753397760
+Version: 3.12.0a1753509641
 Summary: A Pulumi package for creating and managing Kafka.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_kafka-3.11.0a1753397760 → pulumi_kafka-3.12.0a1753509641}/pulumi_kafka.egg-info/SOURCES.txt

@@ -4,6 +4,8 @@ pulumi_kafka/__init__.py
 pulumi_kafka/_utilities.py
 pulumi_kafka/acl.py
 pulumi_kafka/get_topic.py
+pulumi_kafka/get_topics.py
+pulumi_kafka/outputs.py
 pulumi_kafka/provider.py
 pulumi_kafka/pulumi-plugin.json
 pulumi_kafka/py.typed

{pulumi_kafka-3.11.0a1753397760 → pulumi_kafka-3.12.0a1753509641}/pyproject.toml

@@ -5,7 +5,7 @@
   keywords = ["pulumi", "kafka"]
   readme = "README.md"
   requires-python = ">=3.9"
-  version = "3.11.0a1753397760"
+  version = "3.12.0a1753509641"
   [project.license]
     text = "Apache-2.0"
   [project.urls]