pulumi-confluentcloud 2.50.0a1761889162__tar.gz → 2.50.0a1763185030__tar.gz

{pulumi_confluentcloud-2.50.0a1761889162 → pulumi_confluentcloud-2.50.0a1763185030}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_confluentcloud
-Version: 2.50.0a1761889162
+Version: 2.50.0a1763185030
 Summary: A Pulumi package for creating and managing Confluent cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://www.pulumi.com

{pulumi_confluentcloud-2.50.0a1761889162 → pulumi_confluentcloud-2.50.0a1763185030}/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-2.50.0a1761889162 → pulumi_confluentcloud-2.50.0a1763185030}/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-2.50.0a1761889162 → pulumi_confluentcloud-2.50.0a1763185030}/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-2.50.0a1761889162 → pulumi_confluentcloud-2.50.0a1763185030}/pulumi_confluentcloud/pulumi-plugin.json

@@ -1,5 +1,5 @@
 {
   "resource": true,
   "name": "confluentcloud",
-  "version": "2.50.0-alpha.1761889162"
+  "version": "2.50.0-alpha.1763185030"
 }

{pulumi_confluentcloud-2.50.0a1761889162 → pulumi_confluentcloud-2.50.0a1763185030}/pulumi_confluentcloud/schema.py

@@ -446,6 +446,120 @@ class Schema(pulumi.CustomResource):
         """
         ## Example Usage
 
+        ### Option #1: Manage multiple Schema Registry clusters in the same Pulumi Stack
+
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+        import pulumi_std as std
+
+        avro_purchase = confluentcloud.Schema("avro-purchase",
+            schema_registry_cluster={
+                "id": essentials["id"],
+            },
+            rest_endpoint=essentials["restEndpoint"],
+            subject_name="avro-purchase-value",
+            format="AVRO",
+            schema=std.index.file(input="./schemas/avro/purchase.avsc")["result"],
+            credentials={
+                "key": "<Schema Registry API Key for data.confluent_schema_registry_cluster.essentials>",
+                "secret": "<Schema Registry API Secret for data.confluent_schema_registry_cluster.essentials>",
+            })
+        ```
+
+        ### Option #2: Manage a single Schema Registry cluster in the same Pulumi Stack
+
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+        import pulumi_std as std
+
+        avro_purchase = confluentcloud.Schema("avro-purchase",
+            subject_name="avro-purchase-value",
+            format="AVRO",
+            schema=std.index.file(input="./schemas/avro/purchase.avsc")["result"])
+        ```
+
+        ## Getting Started
+
+        The following end-to-end examples might help to get started with `Schema` resource:
+        * single-event-types-avro-schema
+        * single-event-types-proto-schema
+        * single-event-types-proto-schema-with-alias
+        * multiple-event-types-avro-schema
+        * multiple-event-types-proto-schema
+        * field-level-encryption-schema
+
+        ## Additional Examples
+
+        ### Default Option A: Manage the latest schema version only. The resource instance always points to the latest schema version by supporting in-place updates
+
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+        import pulumi_std as std
+
+        # confluent_schema.avro-purchase points to v1.
+        avro_purchase = confluentcloud.Schema("avro-purchase",
+            subject_name="avro-purchase-value",
+            format="AVRO",
+            schema=std.index.file(input="./schemas/avro/purchase.avsc")["result"],
+            metadata={
+                "properties": {
+                    "owner": "Bob Jones",
+                    "email": "bob@acme.com",
+                },
+                "sensitives": [
+                    "s1",
+                    "s2",
+                ],
+                "tags": [
+                    {
+                        "key": "tag1",
+                        "values": ["PII"],
+                    },
+                    {
+                        "key": "tag2",
+                        "values": ["PIIIII"],
+                    },
+                ],
+            },
+            ruleset={
+                "domain_rules": [
+                    {
+                        "name": "encryptPII",
+                        "kind": "TRANSFORM",
+                        "type": "ENCRYPT",
+                        "mode": "WRITEREAD",
+                        "tags": ["PII"],
+                        "params": {
+                            "encrypt.kek.name": "testkek2",
+                        },
+                    },
+                    {
+                        "name": "encrypt",
+                        "kind": "TRANSFORM",
+                        "type": "ENCRYPT",
+                        "mode": "WRITEREAD",
+                        "tags": ["PIIIII"],
+                        "params": {
+                            "encrypt.kek.name": "testkek2",
+                        },
+                    },
+                ],
+                "migration_rules": [{
+                    "name": "encrypt",
+                    "kind": "TRANSFORM",
+                    "type": "ENCRYPT",
+                    "mode": "WRITEREAD",
+                    "tags": ["PIM"],
+                    "params": {
+                        "encrypt.kek.name": "testkekM",
+                    },
+                }],
+            })
+        ```
+
         ## Import
 
         You can import a Schema by using the Schema Registry cluster ID, Subject name, and unique identifier (or `latest` when `recreate_on_update = false`) of the Schema in the format `<Schema Registry cluster ID>/<Subject name>/<Schema identifier>`, for example:
@@ -498,6 +612,120 @@ class Schema(pulumi.CustomResource):
         """
         ## Example Usage
 
+        ### Option #1: Manage multiple Schema Registry clusters in the same Pulumi Stack
+
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+        import pulumi_std as std
+
+        avro_purchase = confluentcloud.Schema("avro-purchase",
+            schema_registry_cluster={
+                "id": essentials["id"],
+            },
+            rest_endpoint=essentials["restEndpoint"],
+            subject_name="avro-purchase-value",
+            format="AVRO",
+            schema=std.index.file(input="./schemas/avro/purchase.avsc")["result"],
+            credentials={
+                "key": "<Schema Registry API Key for data.confluent_schema_registry_cluster.essentials>",
+                "secret": "<Schema Registry API Secret for data.confluent_schema_registry_cluster.essentials>",
+            })
+        ```
+
+        ### Option #2: Manage a single Schema Registry cluster in the same Pulumi Stack
+
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+        import pulumi_std as std
+
+        avro_purchase = confluentcloud.Schema("avro-purchase",
+            subject_name="avro-purchase-value",
+            format="AVRO",
+            schema=std.index.file(input="./schemas/avro/purchase.avsc")["result"])
+        ```
+
+        ## Getting Started
+
+        The following end-to-end examples might help to get started with `Schema` resource:
+        * single-event-types-avro-schema
+        * single-event-types-proto-schema
+        * single-event-types-proto-schema-with-alias
+        * multiple-event-types-avro-schema
+        * multiple-event-types-proto-schema
+        * field-level-encryption-schema
+
+        ## Additional Examples
+
+        ### Default Option A: Manage the latest schema version only. The resource instance always points to the latest schema version by supporting in-place updates
+
+        ```python
+        import pulumi
+        import pulumi_confluentcloud as confluentcloud
+        import pulumi_std as std
+
+        # confluent_schema.avro-purchase points to v1.
+        avro_purchase = confluentcloud.Schema("avro-purchase",
+            subject_name="avro-purchase-value",
+            format="AVRO",
+            schema=std.index.file(input="./schemas/avro/purchase.avsc")["result"],
+            metadata={
+                "properties": {
+                    "owner": "Bob Jones",
+                    "email": "bob@acme.com",
+                },
+                "sensitives": [
+                    "s1",
+                    "s2",
+                ],
+                "tags": [
+                    {
+                        "key": "tag1",
+                        "values": ["PII"],
+                    },
+                    {
+                        "key": "tag2",
+                        "values": ["PIIIII"],
+                    },
+                ],
+            },
+            ruleset={
+                "domain_rules": [
+                    {
+                        "name": "encryptPII",
+                        "kind": "TRANSFORM",
+                        "type": "ENCRYPT",
+                        "mode": "WRITEREAD",
+                        "tags": ["PII"],
+                        "params": {
+                            "encrypt.kek.name": "testkek2",
+                        },
+                    },
+                    {
+                        "name": "encrypt",
+                        "kind": "TRANSFORM",
+                        "type": "ENCRYPT",
+                        "mode": "WRITEREAD",
+                        "tags": ["PIIIII"],
+                        "params": {
+                            "encrypt.kek.name": "testkek2",
+                        },
+                    },
+                ],
+                "migration_rules": [{
+                    "name": "encrypt",
+                    "kind": "TRANSFORM",
+                    "type": "ENCRYPT",
+                    "mode": "WRITEREAD",
+                    "tags": ["PIM"],
+                    "params": {
+                        "encrypt.kek.name": "testkekM",
+                    },
+                }],
+            })
+        ```
+
         ## Import
 
         You can import a Schema by using the Schema Registry cluster ID, Subject name, and unique identifier (or `latest` when `recreate_on_update = false`) of the Schema in the format `<Schema Registry cluster ID>/<Subject name>/<Schema identifier>`, for example:

{pulumi_confluentcloud-2.50.0a1761889162 → pulumi_confluentcloud-2.50.0a1763185030}/pulumi_confluentcloud.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_confluentcloud
-Version: 2.50.0a1761889162
+Version: 2.50.0a1763185030
 Summary: A Pulumi package for creating and managing Confluent cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://www.pulumi.com

{pulumi_confluentcloud-2.50.0a1761889162 → pulumi_confluentcloud-2.50.0a1763185030}/pyproject.toml

@@ -5,7 +5,7 @@
   keywords = ["pulumi", "confluentcloud", "category/cloud"]
   readme = "README.md"
   requires-python = ">=3.9"
-  version = "2.50.0a1761889162"
+  version = "2.50.0a1763185030"
   [project.license]
     text = "Apache-2.0"
   [project.urls]