@pulumi/confluentcloud 2.50.0-alpha.1762926155 → 2.50.0-alpha.1763074470
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/apiKey.d.ts +88 -0
- package/apiKey.js +88 -0
- package/apiKey.js.map +1 -1
- package/dnsForwarder.d.ts +25 -0
- package/dnsForwarder.js +25 -0
- package/dnsForwarder.js.map +1 -1
- package/getCatalogIntegration.d.ts +84 -0
- package/getCatalogIntegration.js +84 -0
- package/getCatalogIntegration.js.map +1 -1
- package/package.json +2 -2
- package/schema.d.ts +123 -0
- package/schema.js +123 -0
- package/schema.js.map +1 -1
package/apiKey.d.ts
CHANGED
|
@@ -5,12 +5,100 @@ import * as outputs from "./types/output";
|
|
|
5
5
|
* ## Example Usage
|
|
6
6
|
*
|
|
7
7
|
* ### Example Kafka API Key
|
|
8
|
+
* ```typescript
|
|
9
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
10
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
11
|
+
*
|
|
12
|
+
* const app_manager_kafka_api_key = new confluentcloud.ApiKey("app-manager-kafka-api-key", {
|
|
13
|
+
* displayName: "app-manager-kafka-api-key",
|
|
14
|
+
* description: "Kafka API Key that is owned by 'app-manager' service account",
|
|
15
|
+
* owner: {
|
|
16
|
+
* id: app_manager.id,
|
|
17
|
+
* apiVersion: app_manager.apiVersion,
|
|
18
|
+
* kind: app_manager.kind,
|
|
19
|
+
* },
|
|
20
|
+
* managedResource: {
|
|
21
|
+
* id: basic.id,
|
|
22
|
+
* apiVersion: basic.apiVersion,
|
|
23
|
+
* kind: basic.kind,
|
|
24
|
+
* environments: [{
|
|
25
|
+
* id: staging.id,
|
|
26
|
+
* }],
|
|
27
|
+
* },
|
|
28
|
+
* });
|
|
29
|
+
* ```
|
|
8
30
|
*
|
|
9
31
|
* ### Example ksqlDB API Key
|
|
32
|
+
* ```typescript
|
|
33
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
34
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
35
|
+
*
|
|
36
|
+
* const ksqldb_api_key = new confluentcloud.ApiKey("ksqldb-api-key", {
|
|
37
|
+
* displayName: "ksqldb-api-key",
|
|
38
|
+
* description: "KsqlDB API Key that is owned by 'app-manager' service account",
|
|
39
|
+
* owner: {
|
|
40
|
+
* id: app_manager.id,
|
|
41
|
+
* apiVersion: app_manager.apiVersion,
|
|
42
|
+
* kind: app_manager.kind,
|
|
43
|
+
* },
|
|
44
|
+
* managedResource: {
|
|
45
|
+
* id: main.id,
|
|
46
|
+
* apiVersion: main.apiVersion,
|
|
47
|
+
* kind: main.kind,
|
|
48
|
+
* environments: [{
|
|
49
|
+
* id: staging.id,
|
|
50
|
+
* }],
|
|
51
|
+
* },
|
|
52
|
+
* });
|
|
53
|
+
* ```
|
|
10
54
|
*
|
|
11
55
|
* ### Example Schema Registry API Key
|
|
56
|
+
* ```typescript
|
|
57
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
58
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
59
|
+
*
|
|
60
|
+
* const env_manager_schema_registry_api_key = new confluentcloud.ApiKey("env-manager-schema-registry-api-key", {
|
|
61
|
+
* displayName: "env-manager-schema-registry-api-key",
|
|
62
|
+
* description: "Schema Registry API Key that is owned by 'env-manager' service account",
|
|
63
|
+
* owner: {
|
|
64
|
+
* id: env_manager.id,
|
|
65
|
+
* apiVersion: env_manager.apiVersion,
|
|
66
|
+
* kind: env_manager.kind,
|
|
67
|
+
* },
|
|
68
|
+
* managedResource: {
|
|
69
|
+
* id: essentials.id,
|
|
70
|
+
* apiVersion: essentials.apiVersion,
|
|
71
|
+
* kind: essentials.kind,
|
|
72
|
+
* environments: [{
|
|
73
|
+
* id: staging.id,
|
|
74
|
+
* }],
|
|
75
|
+
* },
|
|
76
|
+
* });
|
|
77
|
+
* ```
|
|
12
78
|
*
|
|
13
79
|
* ### Example Flink API Key
|
|
80
|
+
* ```typescript
|
|
81
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
82
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
83
|
+
*
|
|
84
|
+
* const env_manager_flink_api_key = new confluentcloud.ApiKey("env-manager-flink-api-key", {
|
|
85
|
+
* displayName: "env-manager-flink-api-key",
|
|
86
|
+
* description: "Flink API Key that is owned by 'env-manager' service account",
|
|
87
|
+
* owner: {
|
|
88
|
+
* id: env_manager.id,
|
|
89
|
+
* apiVersion: env_manager.apiVersion,
|
|
90
|
+
* kind: env_manager.kind,
|
|
91
|
+
* },
|
|
92
|
+
* managedResource: {
|
|
93
|
+
* id: example.id,
|
|
94
|
+
* apiVersion: example.apiVersion,
|
|
95
|
+
* kind: example.kind,
|
|
96
|
+
* environments: [{
|
|
97
|
+
* id: staging.id,
|
|
98
|
+
* }],
|
|
99
|
+
* },
|
|
100
|
+
* });
|
|
101
|
+
* ```
|
|
14
102
|
*
|
|
15
103
|
* ### Example Tableflow API Key
|
|
16
104
|
* ```typescript
|
package/apiKey.js
CHANGED
|
@@ -9,12 +9,100 @@ const utilities = require("./utilities");
|
|
|
9
9
|
* ## Example Usage
|
|
10
10
|
*
|
|
11
11
|
* ### Example Kafka API Key
|
|
12
|
+
* ```typescript
|
|
13
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
14
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
15
|
+
*
|
|
16
|
+
* const app_manager_kafka_api_key = new confluentcloud.ApiKey("app-manager-kafka-api-key", {
|
|
17
|
+
* displayName: "app-manager-kafka-api-key",
|
|
18
|
+
* description: "Kafka API Key that is owned by 'app-manager' service account",
|
|
19
|
+
* owner: {
|
|
20
|
+
* id: app_manager.id,
|
|
21
|
+
* apiVersion: app_manager.apiVersion,
|
|
22
|
+
* kind: app_manager.kind,
|
|
23
|
+
* },
|
|
24
|
+
* managedResource: {
|
|
25
|
+
* id: basic.id,
|
|
26
|
+
* apiVersion: basic.apiVersion,
|
|
27
|
+
* kind: basic.kind,
|
|
28
|
+
* environments: [{
|
|
29
|
+
* id: staging.id,
|
|
30
|
+
* }],
|
|
31
|
+
* },
|
|
32
|
+
* });
|
|
33
|
+
* ```
|
|
12
34
|
*
|
|
13
35
|
* ### Example ksqlDB API Key
|
|
36
|
+
* ```typescript
|
|
37
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
38
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
39
|
+
*
|
|
40
|
+
* const ksqldb_api_key = new confluentcloud.ApiKey("ksqldb-api-key", {
|
|
41
|
+
* displayName: "ksqldb-api-key",
|
|
42
|
+
* description: "KsqlDB API Key that is owned by 'app-manager' service account",
|
|
43
|
+
* owner: {
|
|
44
|
+
* id: app_manager.id,
|
|
45
|
+
* apiVersion: app_manager.apiVersion,
|
|
46
|
+
* kind: app_manager.kind,
|
|
47
|
+
* },
|
|
48
|
+
* managedResource: {
|
|
49
|
+
* id: main.id,
|
|
50
|
+
* apiVersion: main.apiVersion,
|
|
51
|
+
* kind: main.kind,
|
|
52
|
+
* environments: [{
|
|
53
|
+
* id: staging.id,
|
|
54
|
+
* }],
|
|
55
|
+
* },
|
|
56
|
+
* });
|
|
57
|
+
* ```
|
|
14
58
|
*
|
|
15
59
|
* ### Example Schema Registry API Key
|
|
60
|
+
* ```typescript
|
|
61
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
62
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
63
|
+
*
|
|
64
|
+
* const env_manager_schema_registry_api_key = new confluentcloud.ApiKey("env-manager-schema-registry-api-key", {
|
|
65
|
+
* displayName: "env-manager-schema-registry-api-key",
|
|
66
|
+
* description: "Schema Registry API Key that is owned by 'env-manager' service account",
|
|
67
|
+
* owner: {
|
|
68
|
+
* id: env_manager.id,
|
|
69
|
+
* apiVersion: env_manager.apiVersion,
|
|
70
|
+
* kind: env_manager.kind,
|
|
71
|
+
* },
|
|
72
|
+
* managedResource: {
|
|
73
|
+
* id: essentials.id,
|
|
74
|
+
* apiVersion: essentials.apiVersion,
|
|
75
|
+
* kind: essentials.kind,
|
|
76
|
+
* environments: [{
|
|
77
|
+
* id: staging.id,
|
|
78
|
+
* }],
|
|
79
|
+
* },
|
|
80
|
+
* });
|
|
81
|
+
* ```
|
|
16
82
|
*
|
|
17
83
|
* ### Example Flink API Key
|
|
84
|
+
* ```typescript
|
|
85
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
86
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
87
|
+
*
|
|
88
|
+
* const env_manager_flink_api_key = new confluentcloud.ApiKey("env-manager-flink-api-key", {
|
|
89
|
+
* displayName: "env-manager-flink-api-key",
|
|
90
|
+
* description: "Flink API Key that is owned by 'env-manager' service account",
|
|
91
|
+
* owner: {
|
|
92
|
+
* id: env_manager.id,
|
|
93
|
+
* apiVersion: env_manager.apiVersion,
|
|
94
|
+
* kind: env_manager.kind,
|
|
95
|
+
* },
|
|
96
|
+
* managedResource: {
|
|
97
|
+
* id: example.id,
|
|
98
|
+
* apiVersion: example.apiVersion,
|
|
99
|
+
* kind: example.kind,
|
|
100
|
+
* environments: [{
|
|
101
|
+
* id: staging.id,
|
|
102
|
+
* }],
|
|
103
|
+
* },
|
|
104
|
+
* });
|
|
105
|
+
* ```
|
|
18
106
|
*
|
|
19
107
|
* ### Example Tableflow API Key
|
|
20
108
|
* ```typescript
|
package/apiKey.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"apiKey.js","sourceRoot":"","sources":["../apiKey.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC
|
|
1
|
+
{"version":3,"file":"apiKey.js","sourceRoot":"","sources":["../apiKey.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgMG;AACH,MAAa,MAAO,SAAQ,MAAM,CAAC,cAAc;IAC7C;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAA2B,EAAE,KAAmB,EAAE,IAAmC;QACjH,OAAO,IAAI,MAAM,CAAC,IAAI,EAAO,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC7D,CAAC;IAKD;;;OAGG;IACI,MAAM,CAAC,UAAU,CAAC,GAAQ;QAC7B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;YACnC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,GAAG,CAAC,cAAc,CAAC,KAAK,MAAM,CAAC,YAAY,CAAC;IACvD,CAAC;IAmCD,YAAY,IAAY,EAAE,WAAsC,EAAE,IAAmC;QACjG,IAAI,cAAc,GAAkB,EAAE,CAAC;QACvC,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAClB,IAAI,IAAI,CAAC,EAAE,EAAE;YACT,MAAM,KAAK,GAAG,WAAsC,CAAC;YACrD,cAAc,CAAC,aAAa,CAAC,GAAG,KAAK,EAAE,WAAW,CAAC;YACnD,cAAc,CAAC,qBAAqB,CAAC,GAAG,KAAK,EAAE,mBAAmB,CAAC;YACnE,cAAc,CAAC,aAAa,CAAC,GAAG,KAAK,EAAE,WAAW,CAAC;YACnD,cAAc,CAAC,iBAAiB,CAAC,GAAG,KAAK,EAAE,eAAe,CAAC;YAC3D,cAAc,CAAC,OAAO,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC;YACvC,cAAc,CAAC,QAAQ,CAAC,GAAG,KAAK,EAAE,MAAM,CAAC;SAC5C;aAAM;YACH,MAAM,IAAI,GAAG,WAAqC,CAAC;YACnD,IAAI,IAAI,EAAE,KAAK,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBACxC,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;aACxD;YACD,cAAc,CAAC,aAAa,CAAC,GAAG,IAAI,EAAE,WAAW,CAAC;YAClD,cAAc,CAAC,qBAAqB,CAAC,GAAG,IAAI,EAAE,mBAAmB,CAAC;YAClE,cAAc,CAAC,aAAa,CAAC,GAAG,IAAI,EAAE,WAAW,CAAC;YAClD,cAAc,CAAC,iBAAiB,CAAC,GAAG,IAAI,EAAE,eAAe,CAAC;YAC1D,cAAc,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC;YACtC,cAAc,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;SAChD;QACD,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,CAAC,CAAC;QACnE,MAAM,UAAU,GAAG,EAAE,uBAAuB,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC3D,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAC7C,KAAK,CAAC,MAAM,CAAC,YAAY,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;;AAxFL,wBAyFC;AA3EG,gBAAgB;AACO,mBAAY,GAAG,oCAAoC,CAAC"}
|
package/dnsForwarder.d.ts
CHANGED
|
@@ -38,6 +38,31 @@ import * as outputs from "./types/output";
|
|
|
38
38
|
*
|
|
39
39
|
* ### Option #2: Create using ForwardViaGcpDnsZones method
|
|
40
40
|
*
|
|
41
|
+
* ```typescript
|
|
42
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
43
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
44
|
+
*
|
|
45
|
+
* const development = new confluentcloud.Environment("development", {displayName: "Development"});
|
|
46
|
+
* const main = new confluentcloud.DnsForwarder("main", {
|
|
47
|
+
* displayName: "dns_forwarder",
|
|
48
|
+
* environment: {
|
|
49
|
+
* id: development.id,
|
|
50
|
+
* },
|
|
51
|
+
* domains: [
|
|
52
|
+
* "example.com",
|
|
53
|
+
* "domainname.com",
|
|
54
|
+
* ],
|
|
55
|
+
* gateway: {
|
|
56
|
+
* id: mainConfluentNetwork.gateway[0].id,
|
|
57
|
+
* },
|
|
58
|
+
* forwardViaGcpZones: [{
|
|
59
|
+
* domainMappings: {
|
|
60
|
+
* "example.com": "zone-1,project-1",
|
|
61
|
+
* },
|
|
62
|
+
* }],
|
|
63
|
+
* });
|
|
64
|
+
* ```
|
|
65
|
+
*
|
|
41
66
|
* ## Import
|
|
42
67
|
*
|
|
43
68
|
* 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:
|
package/dnsForwarder.js
CHANGED
|
@@ -42,6 +42,31 @@ const utilities = require("./utilities");
|
|
|
42
42
|
*
|
|
43
43
|
* ### Option #2: Create using ForwardViaGcpDnsZones method
|
|
44
44
|
*
|
|
45
|
+
* ```typescript
|
|
46
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
47
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
48
|
+
*
|
|
49
|
+
* const development = new confluentcloud.Environment("development", {displayName: "Development"});
|
|
50
|
+
* const main = new confluentcloud.DnsForwarder("main", {
|
|
51
|
+
* displayName: "dns_forwarder",
|
|
52
|
+
* environment: {
|
|
53
|
+
* id: development.id,
|
|
54
|
+
* },
|
|
55
|
+
* domains: [
|
|
56
|
+
* "example.com",
|
|
57
|
+
* "domainname.com",
|
|
58
|
+
* ],
|
|
59
|
+
* gateway: {
|
|
60
|
+
* id: mainConfluentNetwork.gateway[0].id,
|
|
61
|
+
* },
|
|
62
|
+
* forwardViaGcpZones: [{
|
|
63
|
+
* domainMappings: {
|
|
64
|
+
* "example.com": "zone-1,project-1",
|
|
65
|
+
* },
|
|
66
|
+
* }],
|
|
67
|
+
* });
|
|
68
|
+
* ```
|
|
69
|
+
*
|
|
45
70
|
* ## Import
|
|
46
71
|
*
|
|
47
72
|
* 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:
|
package/dnsForwarder.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"dnsForwarder.js","sourceRoot":"","sources":["../dnsForwarder.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC
|
|
1
|
+
{"version":3,"file":"dnsForwarder.js","sourceRoot":"","sources":["../dnsForwarder.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,MAAa,YAAa,SAAQ,MAAM,CAAC,cAAc;IACnD;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAA2B,EAAE,KAAyB,EAAE,IAAmC;QACvH,OAAO,IAAI,YAAY,CAAC,IAAI,EAAO,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACnE,CAAC;IAKD;;;OAGG;IACI,MAAM,CAAC,UAAU,CAAC,GAAQ;QAC7B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;YACnC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,GAAG,CAAC,cAAc,CAAC,KAAK,YAAY,CAAC,YAAY,CAAC;IAC7D,CAAC;IA0BD,YAAY,IAAY,EAAE,WAAkD,EAAE,IAAmC;QAC7G,IAAI,cAAc,GAAkB,EAAE,CAAC;QACvC,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAClB,IAAI,IAAI,CAAC,EAAE,EAAE;YACT,MAAM,KAAK,GAAG,WAA4C,CAAC;YAC3D,cAAc,CAAC,aAAa,CAAC,GAAG,KAAK,EAAE,WAAW,CAAC;YACnD,cAAc,CAAC,SAAS,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC;YAC3C,cAAc,CAAC,aAAa,CAAC,GAAG,KAAK,EAAE,WAAW,CAAC;YACnD,cAAc,CAAC,uBAAuB,CAAC,GAAG,KAAK,EAAE,qBAAqB,CAAC;YACvE,cAAc,CAAC,cAAc,CAAC,GAAG,KAAK,EAAE,YAAY,CAAC;YACrD,cAAc,CAAC,SAAS,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC;SAC9C;aAAM;YACH,MAAM,IAAI,GAAG,WAA2C,CAAC;YACzD,IAAI,IAAI,EAAE,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC1C,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;aAC1D;YACD,IAAI,IAAI,EAAE,WAAW,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC9C,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;aAC9D;YACD,IAAI,IAAI,EAAE,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC1C,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;aAC1D;YACD,cAAc,CAAC,aAAa,CAAC,GAAG,IAAI,EAAE,WAAW,CAAC;YAClD,cAAc,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC;YAC1C,cAAc,CAAC,aAAa,CAAC,GAAG,IAAI,EAAE,WAAW,CAAC;YAClD,cAAc,CAAC,uBAAuB,CAAC,GAAG,IAAI,EAAE,qBAAqB,CAAC;YACtE,cAAc,CAAC,cAAc,CAAC,GAAG,IAAI,EAAE,YAAY,CAAC;YACpD,cAAc,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC;SAC7C;QACD,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,CAAC,CAAC;QACnE,KAAK,CAAC,YAAY,CAAC,YAAY,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;IACjE,CAAC;;AAnFL,oCAoFC;AAtEG,gBAAgB;AACO,yBAAY,GAAG,gDAAgD,CAAC"}
|
|
@@ -7,6 +7,48 @@ import * as outputs from "./types/output";
|
|
|
7
7
|
* `confluentcloud.CatalogIntegration` describes a Catalog Integration data source.
|
|
8
8
|
*
|
|
9
9
|
* ## Example Usage
|
|
10
|
+
*
|
|
11
|
+
* ### Option #1: Manage multiple Catalog Integrations in the same Pulumi Stack
|
|
12
|
+
*
|
|
13
|
+
* ```typescript
|
|
14
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
15
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
16
|
+
*
|
|
17
|
+
* export = async () => {
|
|
18
|
+
* const example = await confluentcloud.getCatalogIntegration({
|
|
19
|
+
* environment: {
|
|
20
|
+
* id: staging.id,
|
|
21
|
+
* },
|
|
22
|
+
* kafkaCluster: {
|
|
23
|
+
* id: stagingConfluentKafkaCluster.id,
|
|
24
|
+
* },
|
|
25
|
+
* id: "tci-abc123",
|
|
26
|
+
* credentials: {
|
|
27
|
+
* key: env_admin_tableflow_api_key.id,
|
|
28
|
+
* secret: env_admin_tableflow_api_key.secret,
|
|
29
|
+
* },
|
|
30
|
+
* });
|
|
31
|
+
* return {
|
|
32
|
+
* "retention-ms": example.retentionMs,
|
|
33
|
+
* };
|
|
34
|
+
* }
|
|
35
|
+
* ```
|
|
36
|
+
*
|
|
37
|
+
* ### Option #2: Manage a single Catalog Integration in the same Pulumi Stack
|
|
38
|
+
*
|
|
39
|
+
* ```typescript
|
|
40
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
41
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
42
|
+
*
|
|
43
|
+
* export = async () => {
|
|
44
|
+
* const example = await confluentcloud.getCatalogIntegration({
|
|
45
|
+
* id: "tci-abc123",
|
|
46
|
+
* });
|
|
47
|
+
* return {
|
|
48
|
+
* "retention-ms": example.retentionMs,
|
|
49
|
+
* };
|
|
50
|
+
* }
|
|
51
|
+
* ```
|
|
10
52
|
*/
|
|
11
53
|
export declare function getCatalogIntegration(args: GetCatalogIntegrationArgs, opts?: pulumi.InvokeOptions): Promise<GetCatalogIntegrationResult>;
|
|
12
54
|
/**
|
|
@@ -52,6 +94,48 @@ export interface GetCatalogIntegrationResult {
|
|
|
52
94
|
* `confluentcloud.CatalogIntegration` describes a Catalog Integration data source.
|
|
53
95
|
*
|
|
54
96
|
* ## Example Usage
|
|
97
|
+
*
|
|
98
|
+
* ### Option #1: Manage multiple Catalog Integrations in the same Pulumi Stack
|
|
99
|
+
*
|
|
100
|
+
* ```typescript
|
|
101
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
102
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
103
|
+
*
|
|
104
|
+
* export = async () => {
|
|
105
|
+
* const example = await confluentcloud.getCatalogIntegration({
|
|
106
|
+
* environment: {
|
|
107
|
+
* id: staging.id,
|
|
108
|
+
* },
|
|
109
|
+
* kafkaCluster: {
|
|
110
|
+
* id: stagingConfluentKafkaCluster.id,
|
|
111
|
+
* },
|
|
112
|
+
* id: "tci-abc123",
|
|
113
|
+
* credentials: {
|
|
114
|
+
* key: env_admin_tableflow_api_key.id,
|
|
115
|
+
* secret: env_admin_tableflow_api_key.secret,
|
|
116
|
+
* },
|
|
117
|
+
* });
|
|
118
|
+
* return {
|
|
119
|
+
* "retention-ms": example.retentionMs,
|
|
120
|
+
* };
|
|
121
|
+
* }
|
|
122
|
+
* ```
|
|
123
|
+
*
|
|
124
|
+
* ### Option #2: Manage a single Catalog Integration in the same Pulumi Stack
|
|
125
|
+
*
|
|
126
|
+
* ```typescript
|
|
127
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
128
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
129
|
+
*
|
|
130
|
+
* export = async () => {
|
|
131
|
+
* const example = await confluentcloud.getCatalogIntegration({
|
|
132
|
+
* id: "tci-abc123",
|
|
133
|
+
* });
|
|
134
|
+
* return {
|
|
135
|
+
* "retention-ms": example.retentionMs,
|
|
136
|
+
* };
|
|
137
|
+
* }
|
|
138
|
+
* ```
|
|
55
139
|
*/
|
|
56
140
|
export declare function getCatalogIntegrationOutput(args: GetCatalogIntegrationOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetCatalogIntegrationResult>;
|
|
57
141
|
/**
|
package/getCatalogIntegration.js
CHANGED
|
@@ -11,6 +11,48 @@ const utilities = require("./utilities");
|
|
|
11
11
|
* `confluentcloud.CatalogIntegration` describes a Catalog Integration data source.
|
|
12
12
|
*
|
|
13
13
|
* ## Example Usage
|
|
14
|
+
*
|
|
15
|
+
* ### Option #1: Manage multiple Catalog Integrations in the same Pulumi Stack
|
|
16
|
+
*
|
|
17
|
+
* ```typescript
|
|
18
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
19
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
20
|
+
*
|
|
21
|
+
* export = async () => {
|
|
22
|
+
* const example = await confluentcloud.getCatalogIntegration({
|
|
23
|
+
* environment: {
|
|
24
|
+
* id: staging.id,
|
|
25
|
+
* },
|
|
26
|
+
* kafkaCluster: {
|
|
27
|
+
* id: stagingConfluentKafkaCluster.id,
|
|
28
|
+
* },
|
|
29
|
+
* id: "tci-abc123",
|
|
30
|
+
* credentials: {
|
|
31
|
+
* key: env_admin_tableflow_api_key.id,
|
|
32
|
+
* secret: env_admin_tableflow_api_key.secret,
|
|
33
|
+
* },
|
|
34
|
+
* });
|
|
35
|
+
* return {
|
|
36
|
+
* "retention-ms": example.retentionMs,
|
|
37
|
+
* };
|
|
38
|
+
* }
|
|
39
|
+
* ```
|
|
40
|
+
*
|
|
41
|
+
* ### Option #2: Manage a single Catalog Integration in the same Pulumi Stack
|
|
42
|
+
*
|
|
43
|
+
* ```typescript
|
|
44
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
45
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
46
|
+
*
|
|
47
|
+
* export = async () => {
|
|
48
|
+
* const example = await confluentcloud.getCatalogIntegration({
|
|
49
|
+
* id: "tci-abc123",
|
|
50
|
+
* });
|
|
51
|
+
* return {
|
|
52
|
+
* "retention-ms": example.retentionMs,
|
|
53
|
+
* };
|
|
54
|
+
* }
|
|
55
|
+
* ```
|
|
14
56
|
*/
|
|
15
57
|
function getCatalogIntegration(args, opts) {
|
|
16
58
|
opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
|
|
@@ -28,6 +70,48 @@ exports.getCatalogIntegration = getCatalogIntegration;
|
|
|
28
70
|
* `confluentcloud.CatalogIntegration` describes a Catalog Integration data source.
|
|
29
71
|
*
|
|
30
72
|
* ## Example Usage
|
|
73
|
+
*
|
|
74
|
+
* ### Option #1: Manage multiple Catalog Integrations in the same Pulumi Stack
|
|
75
|
+
*
|
|
76
|
+
* ```typescript
|
|
77
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
78
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
79
|
+
*
|
|
80
|
+
* export = async () => {
|
|
81
|
+
* const example = await confluentcloud.getCatalogIntegration({
|
|
82
|
+
* environment: {
|
|
83
|
+
* id: staging.id,
|
|
84
|
+
* },
|
|
85
|
+
* kafkaCluster: {
|
|
86
|
+
* id: stagingConfluentKafkaCluster.id,
|
|
87
|
+
* },
|
|
88
|
+
* id: "tci-abc123",
|
|
89
|
+
* credentials: {
|
|
90
|
+
* key: env_admin_tableflow_api_key.id,
|
|
91
|
+
* secret: env_admin_tableflow_api_key.secret,
|
|
92
|
+
* },
|
|
93
|
+
* });
|
|
94
|
+
* return {
|
|
95
|
+
* "retention-ms": example.retentionMs,
|
|
96
|
+
* };
|
|
97
|
+
* }
|
|
98
|
+
* ```
|
|
99
|
+
*
|
|
100
|
+
* ### Option #2: Manage a single Catalog Integration in the same Pulumi Stack
|
|
101
|
+
*
|
|
102
|
+
* ```typescript
|
|
103
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
104
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
105
|
+
*
|
|
106
|
+
* export = async () => {
|
|
107
|
+
* const example = await confluentcloud.getCatalogIntegration({
|
|
108
|
+
* id: "tci-abc123",
|
|
109
|
+
* });
|
|
110
|
+
* return {
|
|
111
|
+
* "retention-ms": example.retentionMs,
|
|
112
|
+
* };
|
|
113
|
+
* }
|
|
114
|
+
* ```
|
|
31
115
|
*/
|
|
32
116
|
function getCatalogIntegrationOutput(args, opts) {
|
|
33
117
|
opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"getCatalogIntegration.js","sourceRoot":"","sources":["../getCatalogIntegration.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC
|
|
1
|
+
{"version":3,"file":"getCatalogIntegration.js","sourceRoot":"","sources":["../getCatalogIntegration.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,SAAgB,qBAAqB,CAAC,IAA+B,EAAE,IAA2B;IAC9F,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,kEAAkE,EAAE;QAC7F,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,IAAI,EAAE,IAAI,CAAC,EAAE;QACb,cAAc,EAAE,IAAI,CAAC,YAAY;KACpC,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AARD,sDAQC;AAwCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,SAAgB,2BAA2B,CAAC,IAAqC,EAAE,IAAiC;IAChH,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,kEAAkE,EAAE;QACnG,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,IAAI,EAAE,IAAI,CAAC,EAAE;QACb,cAAc,EAAE,IAAI,CAAC,YAAY;KACpC,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AARD,kEAQC"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@pulumi/confluentcloud",
|
|
3
|
-
"version": "2.50.0-alpha.
|
|
3
|
+
"version": "2.50.0-alpha.1763074470",
|
|
4
4
|
"description": "A Pulumi package for creating and managing Confluent cloud resources.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"pulumi",
|
|
@@ -24,6 +24,6 @@
|
|
|
24
24
|
"pulumi": {
|
|
25
25
|
"resource": true,
|
|
26
26
|
"name": "confluentcloud",
|
|
27
|
-
"version": "2.50.0-alpha.
|
|
27
|
+
"version": "2.50.0-alpha.1763074470"
|
|
28
28
|
}
|
|
29
29
|
}
|
package/schema.d.ts
CHANGED
|
@@ -4,6 +4,129 @@ import * as outputs from "./types/output";
|
|
|
4
4
|
/**
|
|
5
5
|
* ## Example Usage
|
|
6
6
|
*
|
|
7
|
+
* ### Option #1: Manage multiple Schema Registry clusters in the same Pulumi Stack
|
|
8
|
+
*
|
|
9
|
+
* ```typescript
|
|
10
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
11
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
12
|
+
* import * as std from "@pulumi/std";
|
|
13
|
+
*
|
|
14
|
+
* const avro_purchase = new confluentcloud.Schema("avro-purchase", {
|
|
15
|
+
* schemaRegistryCluster: {
|
|
16
|
+
* id: essentials.id,
|
|
17
|
+
* },
|
|
18
|
+
* restEndpoint: essentials.restEndpoint,
|
|
19
|
+
* subjectName: "avro-purchase-value",
|
|
20
|
+
* format: "AVRO",
|
|
21
|
+
* schema: std.index.file({
|
|
22
|
+
* input: "./schemas/avro/purchase.avsc",
|
|
23
|
+
* }).result,
|
|
24
|
+
* credentials: {
|
|
25
|
+
* key: "<Schema Registry API Key for data.confluent_schema_registry_cluster.essentials>",
|
|
26
|
+
* secret: "<Schema Registry API Secret for data.confluent_schema_registry_cluster.essentials>",
|
|
27
|
+
* },
|
|
28
|
+
* });
|
|
29
|
+
* ```
|
|
30
|
+
*
|
|
31
|
+
* ### Option #2: Manage a single Schema Registry cluster in the same Pulumi Stack
|
|
32
|
+
*
|
|
33
|
+
* ```typescript
|
|
34
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
35
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
36
|
+
* import * as std from "@pulumi/std";
|
|
37
|
+
*
|
|
38
|
+
* const avro_purchase = new confluentcloud.Schema("avro-purchase", {
|
|
39
|
+
* subjectName: "avro-purchase-value",
|
|
40
|
+
* format: "AVRO",
|
|
41
|
+
* schema: std.index.file({
|
|
42
|
+
* input: "./schemas/avro/purchase.avsc",
|
|
43
|
+
* }).result,
|
|
44
|
+
* });
|
|
45
|
+
* ```
|
|
46
|
+
*
|
|
47
|
+
* ## Getting Started
|
|
48
|
+
*
|
|
49
|
+
* The following end-to-end examples might help to get started with `confluentcloud.Schema` resource:
|
|
50
|
+
* * single-event-types-avro-schema
|
|
51
|
+
* * single-event-types-proto-schema
|
|
52
|
+
* * single-event-types-proto-schema-with-alias
|
|
53
|
+
* * multiple-event-types-avro-schema
|
|
54
|
+
* * multiple-event-types-proto-schema
|
|
55
|
+
* * field-level-encryption-schema
|
|
56
|
+
*
|
|
57
|
+
* ## Additional Examples
|
|
58
|
+
*
|
|
59
|
+
* ### Default Option A: Manage the latest schema version only. The resource instance always points to the latest schema version by supporting in-place updates
|
|
60
|
+
*
|
|
61
|
+
* ```typescript
|
|
62
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
63
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
64
|
+
* import * as std from "@pulumi/std";
|
|
65
|
+
*
|
|
66
|
+
* // confluent_schema.avro-purchase points to v1.
|
|
67
|
+
* const avro_purchase = new confluentcloud.Schema("avro-purchase", {
|
|
68
|
+
* subjectName: "avro-purchase-value",
|
|
69
|
+
* format: "AVRO",
|
|
70
|
+
* schema: std.index.file({
|
|
71
|
+
* input: "./schemas/avro/purchase.avsc",
|
|
72
|
+
* }).result,
|
|
73
|
+
* metadata: {
|
|
74
|
+
* properties: {
|
|
75
|
+
* owner: "Bob Jones",
|
|
76
|
+
* email: "bob@acme.com",
|
|
77
|
+
* },
|
|
78
|
+
* sensitives: [
|
|
79
|
+
* "s1",
|
|
80
|
+
* "s2",
|
|
81
|
+
* ],
|
|
82
|
+
* tags: [
|
|
83
|
+
* {
|
|
84
|
+
* key: "tag1",
|
|
85
|
+
* values: ["PII"],
|
|
86
|
+
* },
|
|
87
|
+
* {
|
|
88
|
+
* key: "tag2",
|
|
89
|
+
* values: ["PIIIII"],
|
|
90
|
+
* },
|
|
91
|
+
* ],
|
|
92
|
+
* },
|
|
93
|
+
* ruleset: {
|
|
94
|
+
* domainRules: [
|
|
95
|
+
* {
|
|
96
|
+
* name: "encryptPII",
|
|
97
|
+
* kind: "TRANSFORM",
|
|
98
|
+
* type: "ENCRYPT",
|
|
99
|
+
* mode: "WRITEREAD",
|
|
100
|
+
* tags: ["PII"],
|
|
101
|
+
* params: {
|
|
102
|
+
* "encrypt.kek.name": "testkek2",
|
|
103
|
+
* },
|
|
104
|
+
* },
|
|
105
|
+
* {
|
|
106
|
+
* name: "encrypt",
|
|
107
|
+
* kind: "TRANSFORM",
|
|
108
|
+
* type: "ENCRYPT",
|
|
109
|
+
* mode: "WRITEREAD",
|
|
110
|
+
* tags: ["PIIIII"],
|
|
111
|
+
* params: {
|
|
112
|
+
* "encrypt.kek.name": "testkek2",
|
|
113
|
+
* },
|
|
114
|
+
* },
|
|
115
|
+
* ],
|
|
116
|
+
* migrationRules: [{
|
|
117
|
+
* name: "encrypt",
|
|
118
|
+
* kind: "TRANSFORM",
|
|
119
|
+
* type: "ENCRYPT",
|
|
120
|
+
* mode: "WRITEREAD",
|
|
121
|
+
* tags: ["PIM"],
|
|
122
|
+
* params: {
|
|
123
|
+
* "encrypt.kek.name": "testkekM",
|
|
124
|
+
* },
|
|
125
|
+
* }],
|
|
126
|
+
* },
|
|
127
|
+
* });
|
|
128
|
+
* ```
|
|
129
|
+
*
|
|
7
130
|
* ## Import
|
|
8
131
|
*
|
|
9
132
|
* 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:
|
package/schema.js
CHANGED
|
@@ -8,6 +8,129 @@ const utilities = require("./utilities");
|
|
|
8
8
|
/**
|
|
9
9
|
* ## Example Usage
|
|
10
10
|
*
|
|
11
|
+
* ### Option #1: Manage multiple Schema Registry clusters in the same Pulumi Stack
|
|
12
|
+
*
|
|
13
|
+
* ```typescript
|
|
14
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
15
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
16
|
+
* import * as std from "@pulumi/std";
|
|
17
|
+
*
|
|
18
|
+
* const avro_purchase = new confluentcloud.Schema("avro-purchase", {
|
|
19
|
+
* schemaRegistryCluster: {
|
|
20
|
+
* id: essentials.id,
|
|
21
|
+
* },
|
|
22
|
+
* restEndpoint: essentials.restEndpoint,
|
|
23
|
+
* subjectName: "avro-purchase-value",
|
|
24
|
+
* format: "AVRO",
|
|
25
|
+
* schema: std.index.file({
|
|
26
|
+
* input: "./schemas/avro/purchase.avsc",
|
|
27
|
+
* }).result,
|
|
28
|
+
* credentials: {
|
|
29
|
+
* key: "<Schema Registry API Key for data.confluent_schema_registry_cluster.essentials>",
|
|
30
|
+
* secret: "<Schema Registry API Secret for data.confluent_schema_registry_cluster.essentials>",
|
|
31
|
+
* },
|
|
32
|
+
* });
|
|
33
|
+
* ```
|
|
34
|
+
*
|
|
35
|
+
* ### Option #2: Manage a single Schema Registry cluster in the same Pulumi Stack
|
|
36
|
+
*
|
|
37
|
+
* ```typescript
|
|
38
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
39
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
40
|
+
* import * as std from "@pulumi/std";
|
|
41
|
+
*
|
|
42
|
+
* const avro_purchase = new confluentcloud.Schema("avro-purchase", {
|
|
43
|
+
* subjectName: "avro-purchase-value",
|
|
44
|
+
* format: "AVRO",
|
|
45
|
+
* schema: std.index.file({
|
|
46
|
+
* input: "./schemas/avro/purchase.avsc",
|
|
47
|
+
* }).result,
|
|
48
|
+
* });
|
|
49
|
+
* ```
|
|
50
|
+
*
|
|
51
|
+
* ## Getting Started
|
|
52
|
+
*
|
|
53
|
+
* The following end-to-end examples might help to get started with `confluentcloud.Schema` resource:
|
|
54
|
+
* * single-event-types-avro-schema
|
|
55
|
+
* * single-event-types-proto-schema
|
|
56
|
+
* * single-event-types-proto-schema-with-alias
|
|
57
|
+
* * multiple-event-types-avro-schema
|
|
58
|
+
* * multiple-event-types-proto-schema
|
|
59
|
+
* * field-level-encryption-schema
|
|
60
|
+
*
|
|
61
|
+
* ## Additional Examples
|
|
62
|
+
*
|
|
63
|
+
* ### Default Option A: Manage the latest schema version only. The resource instance always points to the latest schema version by supporting in-place updates
|
|
64
|
+
*
|
|
65
|
+
* ```typescript
|
|
66
|
+
* import * as pulumi from "@pulumi/pulumi";
|
|
67
|
+
* import * as confluentcloud from "@pulumi/confluentcloud";
|
|
68
|
+
* import * as std from "@pulumi/std";
|
|
69
|
+
*
|
|
70
|
+
* // confluent_schema.avro-purchase points to v1.
|
|
71
|
+
* const avro_purchase = new confluentcloud.Schema("avro-purchase", {
|
|
72
|
+
* subjectName: "avro-purchase-value",
|
|
73
|
+
* format: "AVRO",
|
|
74
|
+
* schema: std.index.file({
|
|
75
|
+
* input: "./schemas/avro/purchase.avsc",
|
|
76
|
+
* }).result,
|
|
77
|
+
* metadata: {
|
|
78
|
+
* properties: {
|
|
79
|
+
* owner: "Bob Jones",
|
|
80
|
+
* email: "bob@acme.com",
|
|
81
|
+
* },
|
|
82
|
+
* sensitives: [
|
|
83
|
+
* "s1",
|
|
84
|
+
* "s2",
|
|
85
|
+
* ],
|
|
86
|
+
* tags: [
|
|
87
|
+
* {
|
|
88
|
+
* key: "tag1",
|
|
89
|
+
* values: ["PII"],
|
|
90
|
+
* },
|
|
91
|
+
* {
|
|
92
|
+
* key: "tag2",
|
|
93
|
+
* values: ["PIIIII"],
|
|
94
|
+
* },
|
|
95
|
+
* ],
|
|
96
|
+
* },
|
|
97
|
+
* ruleset: {
|
|
98
|
+
* domainRules: [
|
|
99
|
+
* {
|
|
100
|
+
* name: "encryptPII",
|
|
101
|
+
* kind: "TRANSFORM",
|
|
102
|
+
* type: "ENCRYPT",
|
|
103
|
+
* mode: "WRITEREAD",
|
|
104
|
+
* tags: ["PII"],
|
|
105
|
+
* params: {
|
|
106
|
+
* "encrypt.kek.name": "testkek2",
|
|
107
|
+
* },
|
|
108
|
+
* },
|
|
109
|
+
* {
|
|
110
|
+
* name: "encrypt",
|
|
111
|
+
* kind: "TRANSFORM",
|
|
112
|
+
* type: "ENCRYPT",
|
|
113
|
+
* mode: "WRITEREAD",
|
|
114
|
+
* tags: ["PIIIII"],
|
|
115
|
+
* params: {
|
|
116
|
+
* "encrypt.kek.name": "testkek2",
|
|
117
|
+
* },
|
|
118
|
+
* },
|
|
119
|
+
* ],
|
|
120
|
+
* migrationRules: [{
|
|
121
|
+
* name: "encrypt",
|
|
122
|
+
* kind: "TRANSFORM",
|
|
123
|
+
* type: "ENCRYPT",
|
|
124
|
+
* mode: "WRITEREAD",
|
|
125
|
+
* tags: ["PIM"],
|
|
126
|
+
* params: {
|
|
127
|
+
* "encrypt.kek.name": "testkekM",
|
|
128
|
+
* },
|
|
129
|
+
* }],
|
|
130
|
+
* },
|
|
131
|
+
* });
|
|
132
|
+
* ```
|
|
133
|
+
*
|
|
11
134
|
* ## Import
|
|
12
135
|
*
|
|
13
136
|
* 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:
|
package/schema.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"schema.js","sourceRoot":"","sources":["../schema.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC
|
|
1
|
+
{"version":3,"file":"schema.js","sourceRoot":"","sources":["../schema.ts"],"names":[],"mappings":"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"}
|