pulumi-gcp 8.23.0a1742538920__py3-none-any.whl → 8.24.0__py3-none-any.whl
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.
- pulumi_gcp/__init__.py +59 -0
- pulumi_gcp/alloydb/_inputs.py +27 -1
- pulumi_gcp/alloydb/outputs.py +33 -2
- pulumi_gcp/applicationintegration/client.py +18 -24
- pulumi_gcp/bigquery/_inputs.py +178 -0
- pulumi_gcp/bigquery/outputs.py +127 -0
- pulumi_gcp/bigquery/reservation.py +189 -1
- pulumi_gcp/bigquery/table.py +61 -0
- pulumi_gcp/bigqueryanalyticshub/listing_subscription.py +11 -7
- pulumi_gcp/bigtable/table.py +7 -7
- pulumi_gcp/chronicle/data_access_label.py +16 -0
- pulumi_gcp/clouddeploy/_inputs.py +20 -0
- pulumi_gcp/clouddeploy/outputs.py +15 -1
- pulumi_gcp/cloudfunctions/function.py +11 -11
- pulumi_gcp/cloudfunctionsv2/function.py +24 -24
- pulumi_gcp/cloudidentity/get_group_transitive_memberships.py +41 -2
- pulumi_gcp/cloudidentity/outputs.py +18 -38
- pulumi_gcp/cloudrunv2/service.py +14 -14
- pulumi_gcp/compute/__init__.py +1 -0
- pulumi_gcp/compute/_inputs.py +616 -18
- pulumi_gcp/compute/firewall_policy.py +20 -0
- pulumi_gcp/compute/get_images.py +172 -0
- pulumi_gcp/compute/get_resource_policy.py +15 -4
- pulumi_gcp/compute/image.py +54 -0
- pulumi_gcp/compute/interconnect.py +14 -7
- pulumi_gcp/compute/outputs.py +710 -18
- pulumi_gcp/compute/region_network_endpoint_group.py +2 -2
- pulumi_gcp/compute/resource_policy.py +169 -3
- pulumi_gcp/compute/router_route_policy.py +16 -0
- pulumi_gcp/compute/subnetwork.py +109 -1
- pulumi_gcp/compute/target_https_proxy.py +7 -7
- pulumi_gcp/config/__init__.pyi +8 -0
- pulumi_gcp/config/vars.py +16 -0
- pulumi_gcp/container/_inputs.py +265 -4
- pulumi_gcp/container/cluster.py +54 -0
- pulumi_gcp/container/get_attached_versions.py +2 -2
- pulumi_gcp/container/get_cluster.py +12 -1
- pulumi_gcp/container/outputs.py +301 -6
- pulumi_gcp/dataform/repository.py +49 -0
- pulumi_gcp/dataproc/_inputs.py +23 -0
- pulumi_gcp/dataproc/get_metastore_service.py +26 -4
- pulumi_gcp/dataproc/metastore_federation.py +56 -0
- pulumi_gcp/dataproc/metastore_service.py +58 -2
- pulumi_gcp/dataproc/outputs.py +27 -0
- pulumi_gcp/eventarc/__init__.py +1 -0
- pulumi_gcp/eventarc/_inputs.py +1758 -0
- pulumi_gcp/eventarc/outputs.py +1337 -0
- pulumi_gcp/eventarc/pipeline.py +1596 -0
- pulumi_gcp/firebase/__init__.py +1 -0
- pulumi_gcp/firebase/_inputs.py +154 -0
- pulumi_gcp/firebase/app_hosting_backend.py +1303 -0
- pulumi_gcp/firebase/hosting_version.py +2 -2
- pulumi_gcp/firebase/outputs.py +127 -0
- pulumi_gcp/kms/get_key_rings.py +39 -2
- pulumi_gcp/lustre/__init__.py +8 -0
- pulumi_gcp/lustre/instance.py +983 -0
- pulumi_gcp/managedkafka/__init__.py +2 -0
- pulumi_gcp/managedkafka/_inputs.py +263 -0
- pulumi_gcp/managedkafka/connect_cluster.py +795 -0
- pulumi_gcp/managedkafka/connector.py +695 -0
- pulumi_gcp/managedkafka/outputs.py +248 -0
- pulumi_gcp/memorystore/_inputs.py +419 -0
- pulumi_gcp/memorystore/get_instance.py +23 -1
- pulumi_gcp/memorystore/instance.py +144 -14
- pulumi_gcp/memorystore/outputs.py +544 -0
- pulumi_gcp/monitoring/uptime_check_config.py +2 -2
- pulumi_gcp/networkmanagement/_inputs.py +422 -91
- pulumi_gcp/networkmanagement/connectivity_test.py +233 -211
- pulumi_gcp/networkmanagement/outputs.py +280 -61
- pulumi_gcp/networksecurity/_inputs.py +1277 -242
- pulumi_gcp/networksecurity/gateway_security_policy.py +0 -7
- pulumi_gcp/networksecurity/intercept_deployment_group.py +44 -16
- pulumi_gcp/networksecurity/intercept_endpoint_group.py +90 -36
- pulumi_gcp/networksecurity/intercept_endpoint_group_association.py +53 -8
- pulumi_gcp/networksecurity/mirroring_deployment.py +22 -0
- pulumi_gcp/networksecurity/mirroring_deployment_group.py +20 -0
- pulumi_gcp/networksecurity/mirroring_endpoint_group.py +24 -0
- pulumi_gcp/networksecurity/mirroring_endpoint_group_association.py +28 -0
- pulumi_gcp/networksecurity/outputs.py +723 -8
- pulumi_gcp/networksecurity/tls_inspection_policy.py +14 -0
- pulumi_gcp/networkservices/gateway.py +242 -120
- pulumi_gcp/organizations/__init__.py +1 -0
- pulumi_gcp/organizations/get_iam_custom_role.py +198 -0
- pulumi_gcp/osconfig/__init__.py +1 -0
- pulumi_gcp/osconfig/_inputs.py +5413 -0
- pulumi_gcp/osconfig/outputs.py +3962 -0
- pulumi_gcp/osconfig/v2_policy_orchestrator.py +971 -0
- pulumi_gcp/projects/__init__.py +2 -0
- pulumi_gcp/projects/get_iam_custom_role.py +198 -0
- pulumi_gcp/projects/get_iam_custom_roles.py +164 -0
- pulumi_gcp/projects/outputs.py +96 -0
- pulumi_gcp/provider.py +80 -0
- pulumi_gcp/pulumi-plugin.json +1 -1
- pulumi_gcp/servicenetworking/peered_dns_domain.py +4 -0
- pulumi_gcp/sql/outputs.py +8 -8
- pulumi_gcp/storage/__init__.py +2 -0
- pulumi_gcp/storage/_inputs.py +740 -6
- pulumi_gcp/storage/control_project_intelligence_config.py +366 -0
- pulumi_gcp/storage/get_control_project_intelligence_config.py +130 -0
- pulumi_gcp/storage/insights_report_config.py +121 -20
- pulumi_gcp/storage/outputs.py +723 -4
- pulumi_gcp/workflows/workflow.py +75 -7
- {pulumi_gcp-8.23.0a1742538920.dist-info → pulumi_gcp-8.24.0.dist-info}/METADATA +1 -1
- {pulumi_gcp-8.23.0a1742538920.dist-info → pulumi_gcp-8.24.0.dist-info}/RECORD +106 -93
- {pulumi_gcp-8.23.0a1742538920.dist-info → pulumi_gcp-8.24.0.dist-info}/WHEEL +1 -1
- {pulumi_gcp-8.23.0a1742538920.dist-info → pulumi_gcp-8.24.0.dist-info}/top_level.txt +0 -0
|
@@ -0,0 +1,1596 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import copy
|
|
6
|
+
import warnings
|
|
7
|
+
import sys
|
|
8
|
+
import pulumi
|
|
9
|
+
import pulumi.runtime
|
|
10
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
15
|
+
from .. import _utilities
|
|
16
|
+
from . import outputs
|
|
17
|
+
from ._inputs import *
|
|
18
|
+
|
|
19
|
+
__all__ = ['PipelineArgs', 'Pipeline']
|
|
20
|
+
|
|
21
|
+
@pulumi.input_type
|
|
22
|
+
class PipelineArgs:
|
|
23
|
+
def __init__(__self__, *,
|
|
24
|
+
destinations: pulumi.Input[Sequence[pulumi.Input['PipelineDestinationArgs']]],
|
|
25
|
+
location: pulumi.Input[str],
|
|
26
|
+
pipeline_id: pulumi.Input[str],
|
|
27
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
28
|
+
crypto_key_name: Optional[pulumi.Input[str]] = None,
|
|
29
|
+
display_name: Optional[pulumi.Input[str]] = None,
|
|
30
|
+
input_payload_format: Optional[pulumi.Input['PipelineInputPayloadFormatArgs']] = None,
|
|
31
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
32
|
+
logging_config: Optional[pulumi.Input['PipelineLoggingConfigArgs']] = None,
|
|
33
|
+
mediations: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineMediationArgs']]]] = None,
|
|
34
|
+
project: Optional[pulumi.Input[str]] = None,
|
|
35
|
+
retry_policy: Optional[pulumi.Input['PipelineRetryPolicyArgs']] = None):
|
|
36
|
+
"""
|
|
37
|
+
The set of arguments for constructing a Pipeline resource.
|
|
38
|
+
:param pulumi.Input[Sequence[pulumi.Input['PipelineDestinationArgs']]] destinations: List of destinations to which messages will be forwarded. Currently,
|
|
39
|
+
exactly one destination is supported per Pipeline.
|
|
40
|
+
Structure is documented below.
|
|
41
|
+
:param pulumi.Input[str] location: Resource ID segment making up resource `name`. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
|
|
42
|
+
:param pulumi.Input[str] pipeline_id: The user-provided ID to be assigned to the Pipeline. It should match the
|
|
43
|
+
format `^a-z?$`.
|
|
44
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: User-defined annotations. See https://google.aip.dev/128#annotations. **Note**: This field is non-authoritative, and
|
|
45
|
+
will only manage the annotations present in your configuration. Please refer to the field 'effective_annotations' for
|
|
46
|
+
all of the annotations present on the resource.
|
|
47
|
+
:param pulumi.Input[str] crypto_key_name: Resource name of a KMS crypto key (managed by the user) used to encrypt/decrypt the event data. If not set, an internal
|
|
48
|
+
Google-owned key will be used to encrypt messages. It must match the pattern
|
|
49
|
+
"projects/{project}/locations/{location}/keyRings/{keyring}/cryptoKeys/{key}".
|
|
50
|
+
:param pulumi.Input[str] display_name: Display name of resource.
|
|
51
|
+
:param pulumi.Input['PipelineInputPayloadFormatArgs'] input_payload_format: Represents the format of message data.
|
|
52
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: User labels attached to the Pipeline that can be used to group resources. An object containing a list of "key": value
|
|
53
|
+
pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }. **Note**: This field is non-authoritative, and will
|
|
54
|
+
only manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
|
|
55
|
+
present on the resource.
|
|
56
|
+
:param pulumi.Input['PipelineLoggingConfigArgs'] logging_config: The configuration for Platform Telemetry logging for Eventarc Advanced resources.
|
|
57
|
+
:param pulumi.Input[Sequence[pulumi.Input['PipelineMediationArgs']]] mediations: List of mediation operations to be performed on the message. Currently, only one Transformation operation is allowed in
|
|
58
|
+
each Pipeline.
|
|
59
|
+
:param pulumi.Input['PipelineRetryPolicyArgs'] retry_policy: The retry policy configuration for the Pipeline. The pipeline exponentially backs off in case the destination is non
|
|
60
|
+
responsive or returns a retryable error code. The default semantics are as follows: The backoff starts with a 5 second
|
|
61
|
+
delay and doubles the delay after each failed attempt (10 seconds, 20 seconds, 40 seconds, etc.). The delay is capped at
|
|
62
|
+
60 seconds by default. Please note that if you set the min_retry_delay and max_retry_delay fields to the same value this
|
|
63
|
+
will make the duration between retries constant.
|
|
64
|
+
"""
|
|
65
|
+
pulumi.set(__self__, "destinations", destinations)
|
|
66
|
+
pulumi.set(__self__, "location", location)
|
|
67
|
+
pulumi.set(__self__, "pipeline_id", pipeline_id)
|
|
68
|
+
if annotations is not None:
|
|
69
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
70
|
+
if crypto_key_name is not None:
|
|
71
|
+
pulumi.set(__self__, "crypto_key_name", crypto_key_name)
|
|
72
|
+
if display_name is not None:
|
|
73
|
+
pulumi.set(__self__, "display_name", display_name)
|
|
74
|
+
if input_payload_format is not None:
|
|
75
|
+
pulumi.set(__self__, "input_payload_format", input_payload_format)
|
|
76
|
+
if labels is not None:
|
|
77
|
+
pulumi.set(__self__, "labels", labels)
|
|
78
|
+
if logging_config is not None:
|
|
79
|
+
pulumi.set(__self__, "logging_config", logging_config)
|
|
80
|
+
if mediations is not None:
|
|
81
|
+
pulumi.set(__self__, "mediations", mediations)
|
|
82
|
+
if project is not None:
|
|
83
|
+
pulumi.set(__self__, "project", project)
|
|
84
|
+
if retry_policy is not None:
|
|
85
|
+
pulumi.set(__self__, "retry_policy", retry_policy)
|
|
86
|
+
|
|
87
|
+
@property
|
|
88
|
+
@pulumi.getter
|
|
89
|
+
def destinations(self) -> pulumi.Input[Sequence[pulumi.Input['PipelineDestinationArgs']]]:
|
|
90
|
+
"""
|
|
91
|
+
List of destinations to which messages will be forwarded. Currently,
|
|
92
|
+
exactly one destination is supported per Pipeline.
|
|
93
|
+
Structure is documented below.
|
|
94
|
+
"""
|
|
95
|
+
return pulumi.get(self, "destinations")
|
|
96
|
+
|
|
97
|
+
@destinations.setter
|
|
98
|
+
def destinations(self, value: pulumi.Input[Sequence[pulumi.Input['PipelineDestinationArgs']]]):
|
|
99
|
+
pulumi.set(self, "destinations", value)
|
|
100
|
+
|
|
101
|
+
@property
|
|
102
|
+
@pulumi.getter
|
|
103
|
+
def location(self) -> pulumi.Input[str]:
|
|
104
|
+
"""
|
|
105
|
+
Resource ID segment making up resource `name`. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
|
|
106
|
+
"""
|
|
107
|
+
return pulumi.get(self, "location")
|
|
108
|
+
|
|
109
|
+
@location.setter
|
|
110
|
+
def location(self, value: pulumi.Input[str]):
|
|
111
|
+
pulumi.set(self, "location", value)
|
|
112
|
+
|
|
113
|
+
@property
|
|
114
|
+
@pulumi.getter(name="pipelineId")
|
|
115
|
+
def pipeline_id(self) -> pulumi.Input[str]:
|
|
116
|
+
"""
|
|
117
|
+
The user-provided ID to be assigned to the Pipeline. It should match the
|
|
118
|
+
format `^a-z?$`.
|
|
119
|
+
"""
|
|
120
|
+
return pulumi.get(self, "pipeline_id")
|
|
121
|
+
|
|
122
|
+
@pipeline_id.setter
|
|
123
|
+
def pipeline_id(self, value: pulumi.Input[str]):
|
|
124
|
+
pulumi.set(self, "pipeline_id", value)
|
|
125
|
+
|
|
126
|
+
@property
|
|
127
|
+
@pulumi.getter
|
|
128
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
129
|
+
"""
|
|
130
|
+
User-defined annotations. See https://google.aip.dev/128#annotations. **Note**: This field is non-authoritative, and
|
|
131
|
+
will only manage the annotations present in your configuration. Please refer to the field 'effective_annotations' for
|
|
132
|
+
all of the annotations present on the resource.
|
|
133
|
+
"""
|
|
134
|
+
return pulumi.get(self, "annotations")
|
|
135
|
+
|
|
136
|
+
@annotations.setter
|
|
137
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
138
|
+
pulumi.set(self, "annotations", value)
|
|
139
|
+
|
|
140
|
+
@property
|
|
141
|
+
@pulumi.getter(name="cryptoKeyName")
|
|
142
|
+
def crypto_key_name(self) -> Optional[pulumi.Input[str]]:
|
|
143
|
+
"""
|
|
144
|
+
Resource name of a KMS crypto key (managed by the user) used to encrypt/decrypt the event data. If not set, an internal
|
|
145
|
+
Google-owned key will be used to encrypt messages. It must match the pattern
|
|
146
|
+
"projects/{project}/locations/{location}/keyRings/{keyring}/cryptoKeys/{key}".
|
|
147
|
+
"""
|
|
148
|
+
return pulumi.get(self, "crypto_key_name")
|
|
149
|
+
|
|
150
|
+
@crypto_key_name.setter
|
|
151
|
+
def crypto_key_name(self, value: Optional[pulumi.Input[str]]):
|
|
152
|
+
pulumi.set(self, "crypto_key_name", value)
|
|
153
|
+
|
|
154
|
+
@property
|
|
155
|
+
@pulumi.getter(name="displayName")
|
|
156
|
+
def display_name(self) -> Optional[pulumi.Input[str]]:
|
|
157
|
+
"""
|
|
158
|
+
Display name of resource.
|
|
159
|
+
"""
|
|
160
|
+
return pulumi.get(self, "display_name")
|
|
161
|
+
|
|
162
|
+
@display_name.setter
|
|
163
|
+
def display_name(self, value: Optional[pulumi.Input[str]]):
|
|
164
|
+
pulumi.set(self, "display_name", value)
|
|
165
|
+
|
|
166
|
+
@property
|
|
167
|
+
@pulumi.getter(name="inputPayloadFormat")
|
|
168
|
+
def input_payload_format(self) -> Optional[pulumi.Input['PipelineInputPayloadFormatArgs']]:
|
|
169
|
+
"""
|
|
170
|
+
Represents the format of message data.
|
|
171
|
+
"""
|
|
172
|
+
return pulumi.get(self, "input_payload_format")
|
|
173
|
+
|
|
174
|
+
@input_payload_format.setter
|
|
175
|
+
def input_payload_format(self, value: Optional[pulumi.Input['PipelineInputPayloadFormatArgs']]):
|
|
176
|
+
pulumi.set(self, "input_payload_format", value)
|
|
177
|
+
|
|
178
|
+
@property
|
|
179
|
+
@pulumi.getter
|
|
180
|
+
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
181
|
+
"""
|
|
182
|
+
User labels attached to the Pipeline that can be used to group resources. An object containing a list of "key": value
|
|
183
|
+
pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }. **Note**: This field is non-authoritative, and will
|
|
184
|
+
only manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
|
|
185
|
+
present on the resource.
|
|
186
|
+
"""
|
|
187
|
+
return pulumi.get(self, "labels")
|
|
188
|
+
|
|
189
|
+
@labels.setter
|
|
190
|
+
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
191
|
+
pulumi.set(self, "labels", value)
|
|
192
|
+
|
|
193
|
+
@property
|
|
194
|
+
@pulumi.getter(name="loggingConfig")
|
|
195
|
+
def logging_config(self) -> Optional[pulumi.Input['PipelineLoggingConfigArgs']]:
|
|
196
|
+
"""
|
|
197
|
+
The configuration for Platform Telemetry logging for Eventarc Advanced resources.
|
|
198
|
+
"""
|
|
199
|
+
return pulumi.get(self, "logging_config")
|
|
200
|
+
|
|
201
|
+
@logging_config.setter
|
|
202
|
+
def logging_config(self, value: Optional[pulumi.Input['PipelineLoggingConfigArgs']]):
|
|
203
|
+
pulumi.set(self, "logging_config", value)
|
|
204
|
+
|
|
205
|
+
@property
|
|
206
|
+
@pulumi.getter
|
|
207
|
+
def mediations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PipelineMediationArgs']]]]:
|
|
208
|
+
"""
|
|
209
|
+
List of mediation operations to be performed on the message. Currently, only one Transformation operation is allowed in
|
|
210
|
+
each Pipeline.
|
|
211
|
+
"""
|
|
212
|
+
return pulumi.get(self, "mediations")
|
|
213
|
+
|
|
214
|
+
@mediations.setter
|
|
215
|
+
def mediations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineMediationArgs']]]]):
|
|
216
|
+
pulumi.set(self, "mediations", value)
|
|
217
|
+
|
|
218
|
+
@property
|
|
219
|
+
@pulumi.getter
|
|
220
|
+
def project(self) -> Optional[pulumi.Input[str]]:
|
|
221
|
+
return pulumi.get(self, "project")
|
|
222
|
+
|
|
223
|
+
@project.setter
|
|
224
|
+
def project(self, value: Optional[pulumi.Input[str]]):
|
|
225
|
+
pulumi.set(self, "project", value)
|
|
226
|
+
|
|
227
|
+
@property
|
|
228
|
+
@pulumi.getter(name="retryPolicy")
|
|
229
|
+
def retry_policy(self) -> Optional[pulumi.Input['PipelineRetryPolicyArgs']]:
|
|
230
|
+
"""
|
|
231
|
+
The retry policy configuration for the Pipeline. The pipeline exponentially backs off in case the destination is non
|
|
232
|
+
responsive or returns a retryable error code. The default semantics are as follows: The backoff starts with a 5 second
|
|
233
|
+
delay and doubles the delay after each failed attempt (10 seconds, 20 seconds, 40 seconds, etc.). The delay is capped at
|
|
234
|
+
60 seconds by default. Please note that if you set the min_retry_delay and max_retry_delay fields to the same value this
|
|
235
|
+
will make the duration between retries constant.
|
|
236
|
+
"""
|
|
237
|
+
return pulumi.get(self, "retry_policy")
|
|
238
|
+
|
|
239
|
+
@retry_policy.setter
|
|
240
|
+
def retry_policy(self, value: Optional[pulumi.Input['PipelineRetryPolicyArgs']]):
|
|
241
|
+
pulumi.set(self, "retry_policy", value)
|
|
242
|
+
|
|
243
|
+
|
|
244
|
+
@pulumi.input_type
|
|
245
|
+
class _PipelineState:
|
|
246
|
+
def __init__(__self__, *,
|
|
247
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
248
|
+
create_time: Optional[pulumi.Input[str]] = None,
|
|
249
|
+
crypto_key_name: Optional[pulumi.Input[str]] = None,
|
|
250
|
+
destinations: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineDestinationArgs']]]] = None,
|
|
251
|
+
display_name: Optional[pulumi.Input[str]] = None,
|
|
252
|
+
effective_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
253
|
+
effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
254
|
+
etag: Optional[pulumi.Input[str]] = None,
|
|
255
|
+
input_payload_format: Optional[pulumi.Input['PipelineInputPayloadFormatArgs']] = None,
|
|
256
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
257
|
+
location: Optional[pulumi.Input[str]] = None,
|
|
258
|
+
logging_config: Optional[pulumi.Input['PipelineLoggingConfigArgs']] = None,
|
|
259
|
+
mediations: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineMediationArgs']]]] = None,
|
|
260
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
261
|
+
pipeline_id: Optional[pulumi.Input[str]] = None,
|
|
262
|
+
project: Optional[pulumi.Input[str]] = None,
|
|
263
|
+
pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
264
|
+
retry_policy: Optional[pulumi.Input['PipelineRetryPolicyArgs']] = None,
|
|
265
|
+
uid: Optional[pulumi.Input[str]] = None,
|
|
266
|
+
update_time: Optional[pulumi.Input[str]] = None):
|
|
267
|
+
"""
|
|
268
|
+
Input properties used for looking up and filtering Pipeline resources.
|
|
269
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: User-defined annotations. See https://google.aip.dev/128#annotations. **Note**: This field is non-authoritative, and
|
|
270
|
+
will only manage the annotations present in your configuration. Please refer to the field 'effective_annotations' for
|
|
271
|
+
all of the annotations present on the resource.
|
|
272
|
+
:param pulumi.Input[str] create_time: The creation time.
|
|
273
|
+
A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
|
|
274
|
+
to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and
|
|
275
|
+
"2014-10-02T15:01:23.045123456Z".
|
|
276
|
+
:param pulumi.Input[str] crypto_key_name: Resource name of a KMS crypto key (managed by the user) used to encrypt/decrypt the event data. If not set, an internal
|
|
277
|
+
Google-owned key will be used to encrypt messages. It must match the pattern
|
|
278
|
+
"projects/{project}/locations/{location}/keyRings/{keyring}/cryptoKeys/{key}".
|
|
279
|
+
:param pulumi.Input[Sequence[pulumi.Input['PipelineDestinationArgs']]] destinations: List of destinations to which messages will be forwarded. Currently,
|
|
280
|
+
exactly one destination is supported per Pipeline.
|
|
281
|
+
Structure is documented below.
|
|
282
|
+
:param pulumi.Input[str] display_name: Display name of resource.
|
|
283
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] effective_labels: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
|
|
284
|
+
:param pulumi.Input[str] etag: This checksum is computed by the server based on the value of
|
|
285
|
+
other fields, and might be sent only on create requests to ensure that the
|
|
286
|
+
client has an up-to-date value before proceeding.
|
|
287
|
+
:param pulumi.Input['PipelineInputPayloadFormatArgs'] input_payload_format: Represents the format of message data.
|
|
288
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: User labels attached to the Pipeline that can be used to group resources. An object containing a list of "key": value
|
|
289
|
+
pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }. **Note**: This field is non-authoritative, and will
|
|
290
|
+
only manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
|
|
291
|
+
present on the resource.
|
|
292
|
+
:param pulumi.Input[str] location: Resource ID segment making up resource `name`. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
|
|
293
|
+
:param pulumi.Input['PipelineLoggingConfigArgs'] logging_config: The configuration for Platform Telemetry logging for Eventarc Advanced resources.
|
|
294
|
+
:param pulumi.Input[Sequence[pulumi.Input['PipelineMediationArgs']]] mediations: List of mediation operations to be performed on the message. Currently, only one Transformation operation is allowed in
|
|
295
|
+
each Pipeline.
|
|
296
|
+
:param pulumi.Input[str] name: The resource name of the Pipeline. Must be unique within the
|
|
297
|
+
location of the project and must be in
|
|
298
|
+
`projects/{project}/locations/{location}/pipelines/{pipeline}` format.
|
|
299
|
+
:param pulumi.Input[str] pipeline_id: The user-provided ID to be assigned to the Pipeline. It should match the
|
|
300
|
+
format `^a-z?$`.
|
|
301
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] pulumi_labels: The combination of labels configured directly on the resource
|
|
302
|
+
and default labels configured on the provider.
|
|
303
|
+
:param pulumi.Input['PipelineRetryPolicyArgs'] retry_policy: The retry policy configuration for the Pipeline. The pipeline exponentially backs off in case the destination is non
|
|
304
|
+
responsive or returns a retryable error code. The default semantics are as follows: The backoff starts with a 5 second
|
|
305
|
+
delay and doubles the delay after each failed attempt (10 seconds, 20 seconds, 40 seconds, etc.). The delay is capped at
|
|
306
|
+
60 seconds by default. Please note that if you set the min_retry_delay and max_retry_delay fields to the same value this
|
|
307
|
+
will make the duration between retries constant.
|
|
308
|
+
:param pulumi.Input[str] uid: Server-assigned unique identifier for the Pipeline. The value
|
|
309
|
+
is a UUID4 string and guaranteed to remain unchanged until the resource is
|
|
310
|
+
deleted.
|
|
311
|
+
:param pulumi.Input[str] update_time: The last-modified time.
|
|
312
|
+
A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
|
|
313
|
+
to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and
|
|
314
|
+
"2014-10-02T15:01:23.045123456Z".
|
|
315
|
+
"""
|
|
316
|
+
if annotations is not None:
|
|
317
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
318
|
+
if create_time is not None:
|
|
319
|
+
pulumi.set(__self__, "create_time", create_time)
|
|
320
|
+
if crypto_key_name is not None:
|
|
321
|
+
pulumi.set(__self__, "crypto_key_name", crypto_key_name)
|
|
322
|
+
if destinations is not None:
|
|
323
|
+
pulumi.set(__self__, "destinations", destinations)
|
|
324
|
+
if display_name is not None:
|
|
325
|
+
pulumi.set(__self__, "display_name", display_name)
|
|
326
|
+
if effective_annotations is not None:
|
|
327
|
+
pulumi.set(__self__, "effective_annotations", effective_annotations)
|
|
328
|
+
if effective_labels is not None:
|
|
329
|
+
pulumi.set(__self__, "effective_labels", effective_labels)
|
|
330
|
+
if etag is not None:
|
|
331
|
+
pulumi.set(__self__, "etag", etag)
|
|
332
|
+
if input_payload_format is not None:
|
|
333
|
+
pulumi.set(__self__, "input_payload_format", input_payload_format)
|
|
334
|
+
if labels is not None:
|
|
335
|
+
pulumi.set(__self__, "labels", labels)
|
|
336
|
+
if location is not None:
|
|
337
|
+
pulumi.set(__self__, "location", location)
|
|
338
|
+
if logging_config is not None:
|
|
339
|
+
pulumi.set(__self__, "logging_config", logging_config)
|
|
340
|
+
if mediations is not None:
|
|
341
|
+
pulumi.set(__self__, "mediations", mediations)
|
|
342
|
+
if name is not None:
|
|
343
|
+
pulumi.set(__self__, "name", name)
|
|
344
|
+
if pipeline_id is not None:
|
|
345
|
+
pulumi.set(__self__, "pipeline_id", pipeline_id)
|
|
346
|
+
if project is not None:
|
|
347
|
+
pulumi.set(__self__, "project", project)
|
|
348
|
+
if pulumi_labels is not None:
|
|
349
|
+
pulumi.set(__self__, "pulumi_labels", pulumi_labels)
|
|
350
|
+
if retry_policy is not None:
|
|
351
|
+
pulumi.set(__self__, "retry_policy", retry_policy)
|
|
352
|
+
if uid is not None:
|
|
353
|
+
pulumi.set(__self__, "uid", uid)
|
|
354
|
+
if update_time is not None:
|
|
355
|
+
pulumi.set(__self__, "update_time", update_time)
|
|
356
|
+
|
|
357
|
+
@property
|
|
358
|
+
@pulumi.getter
|
|
359
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
360
|
+
"""
|
|
361
|
+
User-defined annotations. See https://google.aip.dev/128#annotations. **Note**: This field is non-authoritative, and
|
|
362
|
+
will only manage the annotations present in your configuration. Please refer to the field 'effective_annotations' for
|
|
363
|
+
all of the annotations present on the resource.
|
|
364
|
+
"""
|
|
365
|
+
return pulumi.get(self, "annotations")
|
|
366
|
+
|
|
367
|
+
@annotations.setter
|
|
368
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
369
|
+
pulumi.set(self, "annotations", value)
|
|
370
|
+
|
|
371
|
+
@property
|
|
372
|
+
@pulumi.getter(name="createTime")
|
|
373
|
+
def create_time(self) -> Optional[pulumi.Input[str]]:
|
|
374
|
+
"""
|
|
375
|
+
The creation time.
|
|
376
|
+
A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
|
|
377
|
+
to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and
|
|
378
|
+
"2014-10-02T15:01:23.045123456Z".
|
|
379
|
+
"""
|
|
380
|
+
return pulumi.get(self, "create_time")
|
|
381
|
+
|
|
382
|
+
@create_time.setter
|
|
383
|
+
def create_time(self, value: Optional[pulumi.Input[str]]):
|
|
384
|
+
pulumi.set(self, "create_time", value)
|
|
385
|
+
|
|
386
|
+
@property
|
|
387
|
+
@pulumi.getter(name="cryptoKeyName")
|
|
388
|
+
def crypto_key_name(self) -> Optional[pulumi.Input[str]]:
|
|
389
|
+
"""
|
|
390
|
+
Resource name of a KMS crypto key (managed by the user) used to encrypt/decrypt the event data. If not set, an internal
|
|
391
|
+
Google-owned key will be used to encrypt messages. It must match the pattern
|
|
392
|
+
"projects/{project}/locations/{location}/keyRings/{keyring}/cryptoKeys/{key}".
|
|
393
|
+
"""
|
|
394
|
+
return pulumi.get(self, "crypto_key_name")
|
|
395
|
+
|
|
396
|
+
@crypto_key_name.setter
|
|
397
|
+
def crypto_key_name(self, value: Optional[pulumi.Input[str]]):
|
|
398
|
+
pulumi.set(self, "crypto_key_name", value)
|
|
399
|
+
|
|
400
|
+
@property
|
|
401
|
+
@pulumi.getter
|
|
402
|
+
def destinations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PipelineDestinationArgs']]]]:
|
|
403
|
+
"""
|
|
404
|
+
List of destinations to which messages will be forwarded. Currently,
|
|
405
|
+
exactly one destination is supported per Pipeline.
|
|
406
|
+
Structure is documented below.
|
|
407
|
+
"""
|
|
408
|
+
return pulumi.get(self, "destinations")
|
|
409
|
+
|
|
410
|
+
@destinations.setter
|
|
411
|
+
def destinations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineDestinationArgs']]]]):
|
|
412
|
+
pulumi.set(self, "destinations", value)
|
|
413
|
+
|
|
414
|
+
@property
|
|
415
|
+
@pulumi.getter(name="displayName")
|
|
416
|
+
def display_name(self) -> Optional[pulumi.Input[str]]:
|
|
417
|
+
"""
|
|
418
|
+
Display name of resource.
|
|
419
|
+
"""
|
|
420
|
+
return pulumi.get(self, "display_name")
|
|
421
|
+
|
|
422
|
+
@display_name.setter
|
|
423
|
+
def display_name(self, value: Optional[pulumi.Input[str]]):
|
|
424
|
+
pulumi.set(self, "display_name", value)
|
|
425
|
+
|
|
426
|
+
@property
|
|
427
|
+
@pulumi.getter(name="effectiveAnnotations")
|
|
428
|
+
def effective_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
429
|
+
return pulumi.get(self, "effective_annotations")
|
|
430
|
+
|
|
431
|
+
@effective_annotations.setter
|
|
432
|
+
def effective_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
433
|
+
pulumi.set(self, "effective_annotations", value)
|
|
434
|
+
|
|
435
|
+
@property
|
|
436
|
+
@pulumi.getter(name="effectiveLabels")
|
|
437
|
+
def effective_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
438
|
+
"""
|
|
439
|
+
All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
|
|
440
|
+
"""
|
|
441
|
+
return pulumi.get(self, "effective_labels")
|
|
442
|
+
|
|
443
|
+
@effective_labels.setter
|
|
444
|
+
def effective_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
445
|
+
pulumi.set(self, "effective_labels", value)
|
|
446
|
+
|
|
447
|
+
@property
|
|
448
|
+
@pulumi.getter
|
|
449
|
+
def etag(self) -> Optional[pulumi.Input[str]]:
|
|
450
|
+
"""
|
|
451
|
+
This checksum is computed by the server based on the value of
|
|
452
|
+
other fields, and might be sent only on create requests to ensure that the
|
|
453
|
+
client has an up-to-date value before proceeding.
|
|
454
|
+
"""
|
|
455
|
+
return pulumi.get(self, "etag")
|
|
456
|
+
|
|
457
|
+
@etag.setter
|
|
458
|
+
def etag(self, value: Optional[pulumi.Input[str]]):
|
|
459
|
+
pulumi.set(self, "etag", value)
|
|
460
|
+
|
|
461
|
+
@property
|
|
462
|
+
@pulumi.getter(name="inputPayloadFormat")
|
|
463
|
+
def input_payload_format(self) -> Optional[pulumi.Input['PipelineInputPayloadFormatArgs']]:
|
|
464
|
+
"""
|
|
465
|
+
Represents the format of message data.
|
|
466
|
+
"""
|
|
467
|
+
return pulumi.get(self, "input_payload_format")
|
|
468
|
+
|
|
469
|
+
@input_payload_format.setter
|
|
470
|
+
def input_payload_format(self, value: Optional[pulumi.Input['PipelineInputPayloadFormatArgs']]):
|
|
471
|
+
pulumi.set(self, "input_payload_format", value)
|
|
472
|
+
|
|
473
|
+
@property
|
|
474
|
+
@pulumi.getter
|
|
475
|
+
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
476
|
+
"""
|
|
477
|
+
User labels attached to the Pipeline that can be used to group resources. An object containing a list of "key": value
|
|
478
|
+
pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }. **Note**: This field is non-authoritative, and will
|
|
479
|
+
only manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
|
|
480
|
+
present on the resource.
|
|
481
|
+
"""
|
|
482
|
+
return pulumi.get(self, "labels")
|
|
483
|
+
|
|
484
|
+
@labels.setter
|
|
485
|
+
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
486
|
+
pulumi.set(self, "labels", value)
|
|
487
|
+
|
|
488
|
+
@property
|
|
489
|
+
@pulumi.getter
|
|
490
|
+
def location(self) -> Optional[pulumi.Input[str]]:
|
|
491
|
+
"""
|
|
492
|
+
Resource ID segment making up resource `name`. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
|
|
493
|
+
"""
|
|
494
|
+
return pulumi.get(self, "location")
|
|
495
|
+
|
|
496
|
+
@location.setter
|
|
497
|
+
def location(self, value: Optional[pulumi.Input[str]]):
|
|
498
|
+
pulumi.set(self, "location", value)
|
|
499
|
+
|
|
500
|
+
@property
|
|
501
|
+
@pulumi.getter(name="loggingConfig")
|
|
502
|
+
def logging_config(self) -> Optional[pulumi.Input['PipelineLoggingConfigArgs']]:
|
|
503
|
+
"""
|
|
504
|
+
The configuration for Platform Telemetry logging for Eventarc Advanced resources.
|
|
505
|
+
"""
|
|
506
|
+
return pulumi.get(self, "logging_config")
|
|
507
|
+
|
|
508
|
+
@logging_config.setter
|
|
509
|
+
def logging_config(self, value: Optional[pulumi.Input['PipelineLoggingConfigArgs']]):
|
|
510
|
+
pulumi.set(self, "logging_config", value)
|
|
511
|
+
|
|
512
|
+
@property
|
|
513
|
+
@pulumi.getter
|
|
514
|
+
def mediations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PipelineMediationArgs']]]]:
|
|
515
|
+
"""
|
|
516
|
+
List of mediation operations to be performed on the message. Currently, only one Transformation operation is allowed in
|
|
517
|
+
each Pipeline.
|
|
518
|
+
"""
|
|
519
|
+
return pulumi.get(self, "mediations")
|
|
520
|
+
|
|
521
|
+
@mediations.setter
|
|
522
|
+
def mediations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineMediationArgs']]]]):
|
|
523
|
+
pulumi.set(self, "mediations", value)
|
|
524
|
+
|
|
525
|
+
@property
|
|
526
|
+
@pulumi.getter
|
|
527
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
528
|
+
"""
|
|
529
|
+
The resource name of the Pipeline. Must be unique within the
|
|
530
|
+
location of the project and must be in
|
|
531
|
+
`projects/{project}/locations/{location}/pipelines/{pipeline}` format.
|
|
532
|
+
"""
|
|
533
|
+
return pulumi.get(self, "name")
|
|
534
|
+
|
|
535
|
+
@name.setter
|
|
536
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
537
|
+
pulumi.set(self, "name", value)
|
|
538
|
+
|
|
539
|
+
@property
|
|
540
|
+
@pulumi.getter(name="pipelineId")
|
|
541
|
+
def pipeline_id(self) -> Optional[pulumi.Input[str]]:
|
|
542
|
+
"""
|
|
543
|
+
The user-provided ID to be assigned to the Pipeline. It should match the
|
|
544
|
+
format `^a-z?$`.
|
|
545
|
+
"""
|
|
546
|
+
return pulumi.get(self, "pipeline_id")
|
|
547
|
+
|
|
548
|
+
@pipeline_id.setter
|
|
549
|
+
def pipeline_id(self, value: Optional[pulumi.Input[str]]):
|
|
550
|
+
pulumi.set(self, "pipeline_id", value)
|
|
551
|
+
|
|
552
|
+
@property
|
|
553
|
+
@pulumi.getter
|
|
554
|
+
def project(self) -> Optional[pulumi.Input[str]]:
|
|
555
|
+
return pulumi.get(self, "project")
|
|
556
|
+
|
|
557
|
+
@project.setter
|
|
558
|
+
def project(self, value: Optional[pulumi.Input[str]]):
|
|
559
|
+
pulumi.set(self, "project", value)
|
|
560
|
+
|
|
561
|
+
@property
|
|
562
|
+
@pulumi.getter(name="pulumiLabels")
|
|
563
|
+
def pulumi_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
564
|
+
"""
|
|
565
|
+
The combination of labels configured directly on the resource
|
|
566
|
+
and default labels configured on the provider.
|
|
567
|
+
"""
|
|
568
|
+
return pulumi.get(self, "pulumi_labels")
|
|
569
|
+
|
|
570
|
+
@pulumi_labels.setter
|
|
571
|
+
def pulumi_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
572
|
+
pulumi.set(self, "pulumi_labels", value)
|
|
573
|
+
|
|
574
|
+
@property
|
|
575
|
+
@pulumi.getter(name="retryPolicy")
|
|
576
|
+
def retry_policy(self) -> Optional[pulumi.Input['PipelineRetryPolicyArgs']]:
|
|
577
|
+
"""
|
|
578
|
+
The retry policy configuration for the Pipeline. The pipeline exponentially backs off in case the destination is non
|
|
579
|
+
responsive or returns a retryable error code. The default semantics are as follows: The backoff starts with a 5 second
|
|
580
|
+
delay and doubles the delay after each failed attempt (10 seconds, 20 seconds, 40 seconds, etc.). The delay is capped at
|
|
581
|
+
60 seconds by default. Please note that if you set the min_retry_delay and max_retry_delay fields to the same value this
|
|
582
|
+
will make the duration between retries constant.
|
|
583
|
+
"""
|
|
584
|
+
return pulumi.get(self, "retry_policy")
|
|
585
|
+
|
|
586
|
+
@retry_policy.setter
|
|
587
|
+
def retry_policy(self, value: Optional[pulumi.Input['PipelineRetryPolicyArgs']]):
|
|
588
|
+
pulumi.set(self, "retry_policy", value)
|
|
589
|
+
|
|
590
|
+
@property
|
|
591
|
+
@pulumi.getter
|
|
592
|
+
def uid(self) -> Optional[pulumi.Input[str]]:
|
|
593
|
+
"""
|
|
594
|
+
Server-assigned unique identifier for the Pipeline. The value
|
|
595
|
+
is a UUID4 string and guaranteed to remain unchanged until the resource is
|
|
596
|
+
deleted.
|
|
597
|
+
"""
|
|
598
|
+
return pulumi.get(self, "uid")
|
|
599
|
+
|
|
600
|
+
@uid.setter
|
|
601
|
+
def uid(self, value: Optional[pulumi.Input[str]]):
|
|
602
|
+
pulumi.set(self, "uid", value)
|
|
603
|
+
|
|
604
|
+
@property
|
|
605
|
+
@pulumi.getter(name="updateTime")
|
|
606
|
+
def update_time(self) -> Optional[pulumi.Input[str]]:
|
|
607
|
+
"""
|
|
608
|
+
The last-modified time.
|
|
609
|
+
A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
|
|
610
|
+
to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and
|
|
611
|
+
"2014-10-02T15:01:23.045123456Z".
|
|
612
|
+
"""
|
|
613
|
+
return pulumi.get(self, "update_time")
|
|
614
|
+
|
|
615
|
+
@update_time.setter
|
|
616
|
+
def update_time(self, value: Optional[pulumi.Input[str]]):
|
|
617
|
+
pulumi.set(self, "update_time", value)
|
|
618
|
+
|
|
619
|
+
|
|
620
|
+
class Pipeline(pulumi.CustomResource):
|
|
621
|
+
@overload
|
|
622
|
+
def __init__(__self__,
|
|
623
|
+
resource_name: str,
|
|
624
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
625
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
626
|
+
crypto_key_name: Optional[pulumi.Input[str]] = None,
|
|
627
|
+
destinations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelineDestinationArgs', 'PipelineDestinationArgsDict']]]]] = None,
|
|
628
|
+
display_name: Optional[pulumi.Input[str]] = None,
|
|
629
|
+
input_payload_format: Optional[pulumi.Input[Union['PipelineInputPayloadFormatArgs', 'PipelineInputPayloadFormatArgsDict']]] = None,
|
|
630
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
631
|
+
location: Optional[pulumi.Input[str]] = None,
|
|
632
|
+
logging_config: Optional[pulumi.Input[Union['PipelineLoggingConfigArgs', 'PipelineLoggingConfigArgsDict']]] = None,
|
|
633
|
+
mediations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelineMediationArgs', 'PipelineMediationArgsDict']]]]] = None,
|
|
634
|
+
pipeline_id: Optional[pulumi.Input[str]] = None,
|
|
635
|
+
project: Optional[pulumi.Input[str]] = None,
|
|
636
|
+
retry_policy: Optional[pulumi.Input[Union['PipelineRetryPolicyArgs', 'PipelineRetryPolicyArgsDict']]] = None,
|
|
637
|
+
__props__=None):
|
|
638
|
+
"""
|
|
639
|
+
The Eventarc Pipeline resource
|
|
640
|
+
|
|
641
|
+
To get more information about Pipeline, see:
|
|
642
|
+
|
|
643
|
+
* [API documentation](https://cloud.google.com/eventarc/docs/reference/rest/v1/projects.locations.pipelines)
|
|
644
|
+
* How-to Guides
|
|
645
|
+
* [Official Documentation](https://cloud.google.com/eventarc/advanced/docs/receive-events/create-enrollment)
|
|
646
|
+
|
|
647
|
+
## Example Usage
|
|
648
|
+
|
|
649
|
+
### Eventarc Pipeline With Topic Destination
|
|
650
|
+
|
|
651
|
+
```python
|
|
652
|
+
import pulumi
|
|
653
|
+
import pulumi_gcp as gcp
|
|
654
|
+
|
|
655
|
+
topic = gcp.pubsub.Topic("topic", name="some-topic")
|
|
656
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
657
|
+
location="us-central1",
|
|
658
|
+
pipeline_id="some-pipeline",
|
|
659
|
+
destinations=[{
|
|
660
|
+
"topic": topic.id,
|
|
661
|
+
"network_config": {
|
|
662
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
663
|
+
},
|
|
664
|
+
}],
|
|
665
|
+
labels={
|
|
666
|
+
"test_label": "test-eventarc-label",
|
|
667
|
+
},
|
|
668
|
+
annotations={
|
|
669
|
+
"test_annotation": "test-eventarc-annotation",
|
|
670
|
+
},
|
|
671
|
+
display_name="Testing Pipeline")
|
|
672
|
+
```
|
|
673
|
+
### Eventarc Pipeline With Http Destination
|
|
674
|
+
|
|
675
|
+
```python
|
|
676
|
+
import pulumi
|
|
677
|
+
import pulumi_gcp as gcp
|
|
678
|
+
|
|
679
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
680
|
+
location="us-central1",
|
|
681
|
+
pipeline_id="some-pipeline",
|
|
682
|
+
destinations=[{
|
|
683
|
+
"http_endpoint": {
|
|
684
|
+
"uri": "https://10.77.0.0:80/route",
|
|
685
|
+
},
|
|
686
|
+
"network_config": {
|
|
687
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
688
|
+
},
|
|
689
|
+
}])
|
|
690
|
+
```
|
|
691
|
+
### Eventarc Pipeline With Workflow Destination
|
|
692
|
+
|
|
693
|
+
```python
|
|
694
|
+
import pulumi
|
|
695
|
+
import pulumi_gcp as gcp
|
|
696
|
+
|
|
697
|
+
workflow = gcp.workflows.Workflow("workflow",
|
|
698
|
+
name="some-workflow",
|
|
699
|
+
deletion_protection=False,
|
|
700
|
+
region="us-central1",
|
|
701
|
+
source_contents=\"\"\"# This is a sample workflow, feel free to replace it with your source code
|
|
702
|
+
#
|
|
703
|
+
# This workflow does the following:
|
|
704
|
+
# - reads current time and date information from an external API and stores
|
|
705
|
+
# the response in CurrentDateTime variable
|
|
706
|
+
# - retrieves a list of Wikipedia articles related to the day of the week
|
|
707
|
+
# from CurrentDateTime
|
|
708
|
+
# - returns the list of articles as an output of the workflow
|
|
709
|
+
# FYI, In terraform you need to escape the $$ or it will cause errors.
|
|
710
|
+
|
|
711
|
+
- getCurrentTime:
|
|
712
|
+
call: http.get
|
|
713
|
+
args:
|
|
714
|
+
url: ${sys.get_env("url")}
|
|
715
|
+
result: CurrentDateTime
|
|
716
|
+
- readWikipedia:
|
|
717
|
+
call: http.get
|
|
718
|
+
args:
|
|
719
|
+
url: https://en.wikipedia.org/w/api.php
|
|
720
|
+
query:
|
|
721
|
+
action: opensearch
|
|
722
|
+
search: ${CurrentDateTime.body.dayOfTheWeek}
|
|
723
|
+
result: WikiResult
|
|
724
|
+
- returnOutput:
|
|
725
|
+
return: ${WikiResult.body[1]}
|
|
726
|
+
\"\"\")
|
|
727
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
728
|
+
location="us-central1",
|
|
729
|
+
pipeline_id="some-pipeline",
|
|
730
|
+
destinations=[{
|
|
731
|
+
"workflow": workflow.id,
|
|
732
|
+
"network_config": {
|
|
733
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
734
|
+
},
|
|
735
|
+
}])
|
|
736
|
+
```
|
|
737
|
+
### Eventarc Pipeline With Oidc And Json Format
|
|
738
|
+
|
|
739
|
+
```python
|
|
740
|
+
import pulumi
|
|
741
|
+
import pulumi_gcp as gcp
|
|
742
|
+
|
|
743
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
744
|
+
location="us-central1",
|
|
745
|
+
pipeline_id="some-pipeline",
|
|
746
|
+
destinations=[{
|
|
747
|
+
"http_endpoint": {
|
|
748
|
+
"uri": "https://10.77.0.0:80/route",
|
|
749
|
+
"message_binding_template": "{\\"headers\\":{\\"new-header-key\\": \\"new-header-value\\"}}",
|
|
750
|
+
},
|
|
751
|
+
"network_config": {
|
|
752
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
753
|
+
},
|
|
754
|
+
"authentication_config": {
|
|
755
|
+
"google_oidc": {
|
|
756
|
+
"service_account": "my@service-account.com",
|
|
757
|
+
"audience": "http://www.example.com",
|
|
758
|
+
},
|
|
759
|
+
},
|
|
760
|
+
"output_payload_format": {
|
|
761
|
+
"json": {},
|
|
762
|
+
},
|
|
763
|
+
}],
|
|
764
|
+
input_payload_format={
|
|
765
|
+
"json": {},
|
|
766
|
+
},
|
|
767
|
+
retry_policy={
|
|
768
|
+
"max_retry_delay": "50s",
|
|
769
|
+
"max_attempts": 2,
|
|
770
|
+
"min_retry_delay": "40s",
|
|
771
|
+
},
|
|
772
|
+
mediations=[{
|
|
773
|
+
"transformation": {
|
|
774
|
+
"transformation_template": \"\"\"{
|
|
775
|
+
"id": message.id,
|
|
776
|
+
"datacontenttype": "application/json",
|
|
777
|
+
"data": "{ \\"scrubbed\\": \\"true\\" }"
|
|
778
|
+
}
|
|
779
|
+
\"\"\",
|
|
780
|
+
},
|
|
781
|
+
}],
|
|
782
|
+
logging_config={
|
|
783
|
+
"log_severity": "DEBUG",
|
|
784
|
+
})
|
|
785
|
+
```
|
|
786
|
+
### Eventarc Pipeline With Oauth And Protobuf Format
|
|
787
|
+
|
|
788
|
+
```python
|
|
789
|
+
import pulumi
|
|
790
|
+
import pulumi_gcp as gcp
|
|
791
|
+
|
|
792
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
793
|
+
location="us-central1",
|
|
794
|
+
pipeline_id="some-pipeline",
|
|
795
|
+
destinations=[{
|
|
796
|
+
"http_endpoint": {
|
|
797
|
+
"uri": "https://10.77.0.0:80/route",
|
|
798
|
+
"message_binding_template": "{\\"headers\\":{\\"new-header-key\\": \\"new-header-value\\"}}",
|
|
799
|
+
},
|
|
800
|
+
"network_config": {
|
|
801
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
802
|
+
},
|
|
803
|
+
"authentication_config": {
|
|
804
|
+
"oauth_token": {
|
|
805
|
+
"service_account": "my@service-account.com",
|
|
806
|
+
"scope": "https://www.googleapis.com/auth/cloud-platform",
|
|
807
|
+
},
|
|
808
|
+
},
|
|
809
|
+
"output_payload_format": {
|
|
810
|
+
"protobuf": {
|
|
811
|
+
"schema_definition": \"\"\"syntax = "proto3";
|
|
812
|
+
message schema {
|
|
813
|
+
string name = 1;
|
|
814
|
+
string severity = 2;
|
|
815
|
+
}
|
|
816
|
+
\"\"\",
|
|
817
|
+
},
|
|
818
|
+
},
|
|
819
|
+
}],
|
|
820
|
+
input_payload_format={
|
|
821
|
+
"protobuf": {
|
|
822
|
+
"schema_definition": \"\"\"syntax = "proto3";
|
|
823
|
+
message schema {
|
|
824
|
+
string name = 1;
|
|
825
|
+
string severity = 2;
|
|
826
|
+
}
|
|
827
|
+
\"\"\",
|
|
828
|
+
},
|
|
829
|
+
},
|
|
830
|
+
retry_policy={
|
|
831
|
+
"max_retry_delay": "50s",
|
|
832
|
+
"max_attempts": 2,
|
|
833
|
+
"min_retry_delay": "40s",
|
|
834
|
+
},
|
|
835
|
+
mediations=[{
|
|
836
|
+
"transformation": {
|
|
837
|
+
"transformation_template": \"\"\"{
|
|
838
|
+
"id": message.id,
|
|
839
|
+
"datacontenttype": "application/json",
|
|
840
|
+
"data": "{ \\"scrubbed\\": \\"true\\" }"
|
|
841
|
+
}
|
|
842
|
+
\"\"\",
|
|
843
|
+
},
|
|
844
|
+
}],
|
|
845
|
+
logging_config={
|
|
846
|
+
"log_severity": "DEBUG",
|
|
847
|
+
})
|
|
848
|
+
```
|
|
849
|
+
### Eventarc Pipeline With Cmek And Avro Format
|
|
850
|
+
|
|
851
|
+
```python
|
|
852
|
+
import pulumi
|
|
853
|
+
import pulumi_gcp as gcp
|
|
854
|
+
|
|
855
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
856
|
+
location="us-central1",
|
|
857
|
+
pipeline_id="some-pipeline",
|
|
858
|
+
crypto_key_name="some-key",
|
|
859
|
+
destinations=[{
|
|
860
|
+
"http_endpoint": {
|
|
861
|
+
"uri": "https://10.77.0.0:80/route",
|
|
862
|
+
"message_binding_template": "{\\"headers\\":{\\"new-header-key\\": \\"new-header-value\\"}}",
|
|
863
|
+
},
|
|
864
|
+
"network_config": {
|
|
865
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
866
|
+
},
|
|
867
|
+
"output_payload_format": {
|
|
868
|
+
"avro": {
|
|
869
|
+
"schema_definition": "{\\"type\\": \\"record\\", \\"name\\": \\"my_record\\", \\"fields\\": [{\\"name\\": \\"my_field\\", \\"type\\": \\"string\\"}]}",
|
|
870
|
+
},
|
|
871
|
+
},
|
|
872
|
+
}],
|
|
873
|
+
input_payload_format={
|
|
874
|
+
"avro": {
|
|
875
|
+
"schema_definition": "{\\"type\\": \\"record\\", \\"name\\": \\"my_record\\", \\"fields\\": [{\\"name\\": \\"my_field\\", \\"type\\": \\"string\\"}]}",
|
|
876
|
+
},
|
|
877
|
+
},
|
|
878
|
+
retry_policy={
|
|
879
|
+
"max_retry_delay": "50s",
|
|
880
|
+
"max_attempts": 2,
|
|
881
|
+
"min_retry_delay": "40s",
|
|
882
|
+
},
|
|
883
|
+
mediations=[{
|
|
884
|
+
"transformation": {
|
|
885
|
+
"transformation_template": \"\"\"{
|
|
886
|
+
"id": message.id,
|
|
887
|
+
"datacontenttype": "application/json",
|
|
888
|
+
"data": "{ \\"scrubbed\\": \\"true\\" }"
|
|
889
|
+
}
|
|
890
|
+
\"\"\",
|
|
891
|
+
},
|
|
892
|
+
}],
|
|
893
|
+
logging_config={
|
|
894
|
+
"log_severity": "DEBUG",
|
|
895
|
+
})
|
|
896
|
+
```
|
|
897
|
+
|
|
898
|
+
## Import
|
|
899
|
+
|
|
900
|
+
Pipeline can be imported using any of these accepted formats:
|
|
901
|
+
|
|
902
|
+
* `projects/{{project}}/locations/{{location}}/pipelines/{{pipeline_id}}`
|
|
903
|
+
|
|
904
|
+
* `{{project}}/{{location}}/{{pipeline_id}}`
|
|
905
|
+
|
|
906
|
+
* `{{location}}/{{pipeline_id}}`
|
|
907
|
+
|
|
908
|
+
When using the `pulumi import` command, Pipeline can be imported using one of the formats above. For example:
|
|
909
|
+
|
|
910
|
+
```sh
|
|
911
|
+
$ pulumi import gcp:eventarc/pipeline:Pipeline default projects/{{project}}/locations/{{location}}/pipelines/{{pipeline_id}}
|
|
912
|
+
```
|
|
913
|
+
|
|
914
|
+
```sh
|
|
915
|
+
$ pulumi import gcp:eventarc/pipeline:Pipeline default {{project}}/{{location}}/{{pipeline_id}}
|
|
916
|
+
```
|
|
917
|
+
|
|
918
|
+
```sh
|
|
919
|
+
$ pulumi import gcp:eventarc/pipeline:Pipeline default {{location}}/{{pipeline_id}}
|
|
920
|
+
```
|
|
921
|
+
|
|
922
|
+
:param str resource_name: The name of the resource.
|
|
923
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
924
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: User-defined annotations. See https://google.aip.dev/128#annotations. **Note**: This field is non-authoritative, and
|
|
925
|
+
will only manage the annotations present in your configuration. Please refer to the field 'effective_annotations' for
|
|
926
|
+
all of the annotations present on the resource.
|
|
927
|
+
:param pulumi.Input[str] crypto_key_name: Resource name of a KMS crypto key (managed by the user) used to encrypt/decrypt the event data. If not set, an internal
|
|
928
|
+
Google-owned key will be used to encrypt messages. It must match the pattern
|
|
929
|
+
"projects/{project}/locations/{location}/keyRings/{keyring}/cryptoKeys/{key}".
|
|
930
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['PipelineDestinationArgs', 'PipelineDestinationArgsDict']]]] destinations: List of destinations to which messages will be forwarded. Currently,
|
|
931
|
+
exactly one destination is supported per Pipeline.
|
|
932
|
+
Structure is documented below.
|
|
933
|
+
:param pulumi.Input[str] display_name: Display name of resource.
|
|
934
|
+
:param pulumi.Input[Union['PipelineInputPayloadFormatArgs', 'PipelineInputPayloadFormatArgsDict']] input_payload_format: Represents the format of message data.
|
|
935
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: User labels attached to the Pipeline that can be used to group resources. An object containing a list of "key": value
|
|
936
|
+
pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }. **Note**: This field is non-authoritative, and will
|
|
937
|
+
only manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
|
|
938
|
+
present on the resource.
|
|
939
|
+
:param pulumi.Input[str] location: Resource ID segment making up resource `name`. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
|
|
940
|
+
:param pulumi.Input[Union['PipelineLoggingConfigArgs', 'PipelineLoggingConfigArgsDict']] logging_config: The configuration for Platform Telemetry logging for Eventarc Advanced resources.
|
|
941
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['PipelineMediationArgs', 'PipelineMediationArgsDict']]]] mediations: List of mediation operations to be performed on the message. Currently, only one Transformation operation is allowed in
|
|
942
|
+
each Pipeline.
|
|
943
|
+
:param pulumi.Input[str] pipeline_id: The user-provided ID to be assigned to the Pipeline. It should match the
|
|
944
|
+
format `^a-z?$`.
|
|
945
|
+
:param pulumi.Input[Union['PipelineRetryPolicyArgs', 'PipelineRetryPolicyArgsDict']] retry_policy: The retry policy configuration for the Pipeline. The pipeline exponentially backs off in case the destination is non
|
|
946
|
+
responsive or returns a retryable error code. The default semantics are as follows: The backoff starts with a 5 second
|
|
947
|
+
delay and doubles the delay after each failed attempt (10 seconds, 20 seconds, 40 seconds, etc.). The delay is capped at
|
|
948
|
+
60 seconds by default. Please note that if you set the min_retry_delay and max_retry_delay fields to the same value this
|
|
949
|
+
will make the duration between retries constant.
|
|
950
|
+
"""
|
|
951
|
+
...
|
|
952
|
+
@overload
|
|
953
|
+
def __init__(__self__,
|
|
954
|
+
resource_name: str,
|
|
955
|
+
args: PipelineArgs,
|
|
956
|
+
opts: Optional[pulumi.ResourceOptions] = None):
|
|
957
|
+
"""
|
|
958
|
+
The Eventarc Pipeline resource
|
|
959
|
+
|
|
960
|
+
To get more information about Pipeline, see:
|
|
961
|
+
|
|
962
|
+
* [API documentation](https://cloud.google.com/eventarc/docs/reference/rest/v1/projects.locations.pipelines)
|
|
963
|
+
* How-to Guides
|
|
964
|
+
* [Official Documentation](https://cloud.google.com/eventarc/advanced/docs/receive-events/create-enrollment)
|
|
965
|
+
|
|
966
|
+
## Example Usage
|
|
967
|
+
|
|
968
|
+
### Eventarc Pipeline With Topic Destination
|
|
969
|
+
|
|
970
|
+
```python
|
|
971
|
+
import pulumi
|
|
972
|
+
import pulumi_gcp as gcp
|
|
973
|
+
|
|
974
|
+
topic = gcp.pubsub.Topic("topic", name="some-topic")
|
|
975
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
976
|
+
location="us-central1",
|
|
977
|
+
pipeline_id="some-pipeline",
|
|
978
|
+
destinations=[{
|
|
979
|
+
"topic": topic.id,
|
|
980
|
+
"network_config": {
|
|
981
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
982
|
+
},
|
|
983
|
+
}],
|
|
984
|
+
labels={
|
|
985
|
+
"test_label": "test-eventarc-label",
|
|
986
|
+
},
|
|
987
|
+
annotations={
|
|
988
|
+
"test_annotation": "test-eventarc-annotation",
|
|
989
|
+
},
|
|
990
|
+
display_name="Testing Pipeline")
|
|
991
|
+
```
|
|
992
|
+
### Eventarc Pipeline With Http Destination
|
|
993
|
+
|
|
994
|
+
```python
|
|
995
|
+
import pulumi
|
|
996
|
+
import pulumi_gcp as gcp
|
|
997
|
+
|
|
998
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
999
|
+
location="us-central1",
|
|
1000
|
+
pipeline_id="some-pipeline",
|
|
1001
|
+
destinations=[{
|
|
1002
|
+
"http_endpoint": {
|
|
1003
|
+
"uri": "https://10.77.0.0:80/route",
|
|
1004
|
+
},
|
|
1005
|
+
"network_config": {
|
|
1006
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
1007
|
+
},
|
|
1008
|
+
}])
|
|
1009
|
+
```
|
|
1010
|
+
### Eventarc Pipeline With Workflow Destination
|
|
1011
|
+
|
|
1012
|
+
```python
|
|
1013
|
+
import pulumi
|
|
1014
|
+
import pulumi_gcp as gcp
|
|
1015
|
+
|
|
1016
|
+
workflow = gcp.workflows.Workflow("workflow",
|
|
1017
|
+
name="some-workflow",
|
|
1018
|
+
deletion_protection=False,
|
|
1019
|
+
region="us-central1",
|
|
1020
|
+
source_contents=\"\"\"# This is a sample workflow, feel free to replace it with your source code
|
|
1021
|
+
#
|
|
1022
|
+
# This workflow does the following:
|
|
1023
|
+
# - reads current time and date information from an external API and stores
|
|
1024
|
+
# the response in CurrentDateTime variable
|
|
1025
|
+
# - retrieves a list of Wikipedia articles related to the day of the week
|
|
1026
|
+
# from CurrentDateTime
|
|
1027
|
+
# - returns the list of articles as an output of the workflow
|
|
1028
|
+
# FYI, In terraform you need to escape the $$ or it will cause errors.
|
|
1029
|
+
|
|
1030
|
+
- getCurrentTime:
|
|
1031
|
+
call: http.get
|
|
1032
|
+
args:
|
|
1033
|
+
url: ${sys.get_env("url")}
|
|
1034
|
+
result: CurrentDateTime
|
|
1035
|
+
- readWikipedia:
|
|
1036
|
+
call: http.get
|
|
1037
|
+
args:
|
|
1038
|
+
url: https://en.wikipedia.org/w/api.php
|
|
1039
|
+
query:
|
|
1040
|
+
action: opensearch
|
|
1041
|
+
search: ${CurrentDateTime.body.dayOfTheWeek}
|
|
1042
|
+
result: WikiResult
|
|
1043
|
+
- returnOutput:
|
|
1044
|
+
return: ${WikiResult.body[1]}
|
|
1045
|
+
\"\"\")
|
|
1046
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
1047
|
+
location="us-central1",
|
|
1048
|
+
pipeline_id="some-pipeline",
|
|
1049
|
+
destinations=[{
|
|
1050
|
+
"workflow": workflow.id,
|
|
1051
|
+
"network_config": {
|
|
1052
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
1053
|
+
},
|
|
1054
|
+
}])
|
|
1055
|
+
```
|
|
1056
|
+
### Eventarc Pipeline With Oidc And Json Format
|
|
1057
|
+
|
|
1058
|
+
```python
|
|
1059
|
+
import pulumi
|
|
1060
|
+
import pulumi_gcp as gcp
|
|
1061
|
+
|
|
1062
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
1063
|
+
location="us-central1",
|
|
1064
|
+
pipeline_id="some-pipeline",
|
|
1065
|
+
destinations=[{
|
|
1066
|
+
"http_endpoint": {
|
|
1067
|
+
"uri": "https://10.77.0.0:80/route",
|
|
1068
|
+
"message_binding_template": "{\\"headers\\":{\\"new-header-key\\": \\"new-header-value\\"}}",
|
|
1069
|
+
},
|
|
1070
|
+
"network_config": {
|
|
1071
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
1072
|
+
},
|
|
1073
|
+
"authentication_config": {
|
|
1074
|
+
"google_oidc": {
|
|
1075
|
+
"service_account": "my@service-account.com",
|
|
1076
|
+
"audience": "http://www.example.com",
|
|
1077
|
+
},
|
|
1078
|
+
},
|
|
1079
|
+
"output_payload_format": {
|
|
1080
|
+
"json": {},
|
|
1081
|
+
},
|
|
1082
|
+
}],
|
|
1083
|
+
input_payload_format={
|
|
1084
|
+
"json": {},
|
|
1085
|
+
},
|
|
1086
|
+
retry_policy={
|
|
1087
|
+
"max_retry_delay": "50s",
|
|
1088
|
+
"max_attempts": 2,
|
|
1089
|
+
"min_retry_delay": "40s",
|
|
1090
|
+
},
|
|
1091
|
+
mediations=[{
|
|
1092
|
+
"transformation": {
|
|
1093
|
+
"transformation_template": \"\"\"{
|
|
1094
|
+
"id": message.id,
|
|
1095
|
+
"datacontenttype": "application/json",
|
|
1096
|
+
"data": "{ \\"scrubbed\\": \\"true\\" }"
|
|
1097
|
+
}
|
|
1098
|
+
\"\"\",
|
|
1099
|
+
},
|
|
1100
|
+
}],
|
|
1101
|
+
logging_config={
|
|
1102
|
+
"log_severity": "DEBUG",
|
|
1103
|
+
})
|
|
1104
|
+
```
|
|
1105
|
+
### Eventarc Pipeline With Oauth And Protobuf Format
|
|
1106
|
+
|
|
1107
|
+
```python
|
|
1108
|
+
import pulumi
|
|
1109
|
+
import pulumi_gcp as gcp
|
|
1110
|
+
|
|
1111
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
1112
|
+
location="us-central1",
|
|
1113
|
+
pipeline_id="some-pipeline",
|
|
1114
|
+
destinations=[{
|
|
1115
|
+
"http_endpoint": {
|
|
1116
|
+
"uri": "https://10.77.0.0:80/route",
|
|
1117
|
+
"message_binding_template": "{\\"headers\\":{\\"new-header-key\\": \\"new-header-value\\"}}",
|
|
1118
|
+
},
|
|
1119
|
+
"network_config": {
|
|
1120
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
1121
|
+
},
|
|
1122
|
+
"authentication_config": {
|
|
1123
|
+
"oauth_token": {
|
|
1124
|
+
"service_account": "my@service-account.com",
|
|
1125
|
+
"scope": "https://www.googleapis.com/auth/cloud-platform",
|
|
1126
|
+
},
|
|
1127
|
+
},
|
|
1128
|
+
"output_payload_format": {
|
|
1129
|
+
"protobuf": {
|
|
1130
|
+
"schema_definition": \"\"\"syntax = "proto3";
|
|
1131
|
+
message schema {
|
|
1132
|
+
string name = 1;
|
|
1133
|
+
string severity = 2;
|
|
1134
|
+
}
|
|
1135
|
+
\"\"\",
|
|
1136
|
+
},
|
|
1137
|
+
},
|
|
1138
|
+
}],
|
|
1139
|
+
input_payload_format={
|
|
1140
|
+
"protobuf": {
|
|
1141
|
+
"schema_definition": \"\"\"syntax = "proto3";
|
|
1142
|
+
message schema {
|
|
1143
|
+
string name = 1;
|
|
1144
|
+
string severity = 2;
|
|
1145
|
+
}
|
|
1146
|
+
\"\"\",
|
|
1147
|
+
},
|
|
1148
|
+
},
|
|
1149
|
+
retry_policy={
|
|
1150
|
+
"max_retry_delay": "50s",
|
|
1151
|
+
"max_attempts": 2,
|
|
1152
|
+
"min_retry_delay": "40s",
|
|
1153
|
+
},
|
|
1154
|
+
mediations=[{
|
|
1155
|
+
"transformation": {
|
|
1156
|
+
"transformation_template": \"\"\"{
|
|
1157
|
+
"id": message.id,
|
|
1158
|
+
"datacontenttype": "application/json",
|
|
1159
|
+
"data": "{ \\"scrubbed\\": \\"true\\" }"
|
|
1160
|
+
}
|
|
1161
|
+
\"\"\",
|
|
1162
|
+
},
|
|
1163
|
+
}],
|
|
1164
|
+
logging_config={
|
|
1165
|
+
"log_severity": "DEBUG",
|
|
1166
|
+
})
|
|
1167
|
+
```
|
|
1168
|
+
### Eventarc Pipeline With Cmek And Avro Format
|
|
1169
|
+
|
|
1170
|
+
```python
|
|
1171
|
+
import pulumi
|
|
1172
|
+
import pulumi_gcp as gcp
|
|
1173
|
+
|
|
1174
|
+
primary = gcp.eventarc.Pipeline("primary",
|
|
1175
|
+
location="us-central1",
|
|
1176
|
+
pipeline_id="some-pipeline",
|
|
1177
|
+
crypto_key_name="some-key",
|
|
1178
|
+
destinations=[{
|
|
1179
|
+
"http_endpoint": {
|
|
1180
|
+
"uri": "https://10.77.0.0:80/route",
|
|
1181
|
+
"message_binding_template": "{\\"headers\\":{\\"new-header-key\\": \\"new-header-value\\"}}",
|
|
1182
|
+
},
|
|
1183
|
+
"network_config": {
|
|
1184
|
+
"network_attachment": "projects/my-project-name/regions/us-central1/networkAttachments/some-network-attachment",
|
|
1185
|
+
},
|
|
1186
|
+
"output_payload_format": {
|
|
1187
|
+
"avro": {
|
|
1188
|
+
"schema_definition": "{\\"type\\": \\"record\\", \\"name\\": \\"my_record\\", \\"fields\\": [{\\"name\\": \\"my_field\\", \\"type\\": \\"string\\"}]}",
|
|
1189
|
+
},
|
|
1190
|
+
},
|
|
1191
|
+
}],
|
|
1192
|
+
input_payload_format={
|
|
1193
|
+
"avro": {
|
|
1194
|
+
"schema_definition": "{\\"type\\": \\"record\\", \\"name\\": \\"my_record\\", \\"fields\\": [{\\"name\\": \\"my_field\\", \\"type\\": \\"string\\"}]}",
|
|
1195
|
+
},
|
|
1196
|
+
},
|
|
1197
|
+
retry_policy={
|
|
1198
|
+
"max_retry_delay": "50s",
|
|
1199
|
+
"max_attempts": 2,
|
|
1200
|
+
"min_retry_delay": "40s",
|
|
1201
|
+
},
|
|
1202
|
+
mediations=[{
|
|
1203
|
+
"transformation": {
|
|
1204
|
+
"transformation_template": \"\"\"{
|
|
1205
|
+
"id": message.id,
|
|
1206
|
+
"datacontenttype": "application/json",
|
|
1207
|
+
"data": "{ \\"scrubbed\\": \\"true\\" }"
|
|
1208
|
+
}
|
|
1209
|
+
\"\"\",
|
|
1210
|
+
},
|
|
1211
|
+
}],
|
|
1212
|
+
logging_config={
|
|
1213
|
+
"log_severity": "DEBUG",
|
|
1214
|
+
})
|
|
1215
|
+
```
|
|
1216
|
+
|
|
1217
|
+
## Import
|
|
1218
|
+
|
|
1219
|
+
Pipeline can be imported using any of these accepted formats:
|
|
1220
|
+
|
|
1221
|
+
* `projects/{{project}}/locations/{{location}}/pipelines/{{pipeline_id}}`
|
|
1222
|
+
|
|
1223
|
+
* `{{project}}/{{location}}/{{pipeline_id}}`
|
|
1224
|
+
|
|
1225
|
+
* `{{location}}/{{pipeline_id}}`
|
|
1226
|
+
|
|
1227
|
+
When using the `pulumi import` command, Pipeline can be imported using one of the formats above. For example:
|
|
1228
|
+
|
|
1229
|
+
```sh
|
|
1230
|
+
$ pulumi import gcp:eventarc/pipeline:Pipeline default projects/{{project}}/locations/{{location}}/pipelines/{{pipeline_id}}
|
|
1231
|
+
```
|
|
1232
|
+
|
|
1233
|
+
```sh
|
|
1234
|
+
$ pulumi import gcp:eventarc/pipeline:Pipeline default {{project}}/{{location}}/{{pipeline_id}}
|
|
1235
|
+
```
|
|
1236
|
+
|
|
1237
|
+
```sh
|
|
1238
|
+
$ pulumi import gcp:eventarc/pipeline:Pipeline default {{location}}/{{pipeline_id}}
|
|
1239
|
+
```
|
|
1240
|
+
|
|
1241
|
+
:param str resource_name: The name of the resource.
|
|
1242
|
+
:param PipelineArgs args: The arguments to use to populate this resource's properties.
|
|
1243
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1244
|
+
"""
|
|
1245
|
+
...
|
|
1246
|
+
def __init__(__self__, resource_name: str, *args, **kwargs):
|
|
1247
|
+
resource_args, opts = _utilities.get_resource_args_opts(PipelineArgs, pulumi.ResourceOptions, *args, **kwargs)
|
|
1248
|
+
if resource_args is not None:
|
|
1249
|
+
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
|
|
1250
|
+
else:
|
|
1251
|
+
__self__._internal_init(resource_name, *args, **kwargs)
|
|
1252
|
+
|
|
1253
|
+
def _internal_init(__self__,
|
|
1254
|
+
resource_name: str,
|
|
1255
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1256
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1257
|
+
crypto_key_name: Optional[pulumi.Input[str]] = None,
|
|
1258
|
+
destinations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelineDestinationArgs', 'PipelineDestinationArgsDict']]]]] = None,
|
|
1259
|
+
display_name: Optional[pulumi.Input[str]] = None,
|
|
1260
|
+
input_payload_format: Optional[pulumi.Input[Union['PipelineInputPayloadFormatArgs', 'PipelineInputPayloadFormatArgsDict']]] = None,
|
|
1261
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1262
|
+
location: Optional[pulumi.Input[str]] = None,
|
|
1263
|
+
logging_config: Optional[pulumi.Input[Union['PipelineLoggingConfigArgs', 'PipelineLoggingConfigArgsDict']]] = None,
|
|
1264
|
+
mediations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelineMediationArgs', 'PipelineMediationArgsDict']]]]] = None,
|
|
1265
|
+
pipeline_id: Optional[pulumi.Input[str]] = None,
|
|
1266
|
+
project: Optional[pulumi.Input[str]] = None,
|
|
1267
|
+
retry_policy: Optional[pulumi.Input[Union['PipelineRetryPolicyArgs', 'PipelineRetryPolicyArgsDict']]] = None,
|
|
1268
|
+
__props__=None):
|
|
1269
|
+
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1270
|
+
if not isinstance(opts, pulumi.ResourceOptions):
|
|
1271
|
+
raise TypeError('Expected resource options to be a ResourceOptions instance')
|
|
1272
|
+
if opts.id is None:
|
|
1273
|
+
if __props__ is not None:
|
|
1274
|
+
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
1275
|
+
__props__ = PipelineArgs.__new__(PipelineArgs)
|
|
1276
|
+
|
|
1277
|
+
__props__.__dict__["annotations"] = annotations
|
|
1278
|
+
__props__.__dict__["crypto_key_name"] = crypto_key_name
|
|
1279
|
+
if destinations is None and not opts.urn:
|
|
1280
|
+
raise TypeError("Missing required property 'destinations'")
|
|
1281
|
+
__props__.__dict__["destinations"] = destinations
|
|
1282
|
+
__props__.__dict__["display_name"] = display_name
|
|
1283
|
+
__props__.__dict__["input_payload_format"] = input_payload_format
|
|
1284
|
+
__props__.__dict__["labels"] = labels
|
|
1285
|
+
if location is None and not opts.urn:
|
|
1286
|
+
raise TypeError("Missing required property 'location'")
|
|
1287
|
+
__props__.__dict__["location"] = location
|
|
1288
|
+
__props__.__dict__["logging_config"] = logging_config
|
|
1289
|
+
__props__.__dict__["mediations"] = mediations
|
|
1290
|
+
if pipeline_id is None and not opts.urn:
|
|
1291
|
+
raise TypeError("Missing required property 'pipeline_id'")
|
|
1292
|
+
__props__.__dict__["pipeline_id"] = pipeline_id
|
|
1293
|
+
__props__.__dict__["project"] = project
|
|
1294
|
+
__props__.__dict__["retry_policy"] = retry_policy
|
|
1295
|
+
__props__.__dict__["create_time"] = None
|
|
1296
|
+
__props__.__dict__["effective_annotations"] = None
|
|
1297
|
+
__props__.__dict__["effective_labels"] = None
|
|
1298
|
+
__props__.__dict__["etag"] = None
|
|
1299
|
+
__props__.__dict__["name"] = None
|
|
1300
|
+
__props__.__dict__["pulumi_labels"] = None
|
|
1301
|
+
__props__.__dict__["uid"] = None
|
|
1302
|
+
__props__.__dict__["update_time"] = None
|
|
1303
|
+
secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["effectiveLabels", "pulumiLabels"])
|
|
1304
|
+
opts = pulumi.ResourceOptions.merge(opts, secret_opts)
|
|
1305
|
+
super(Pipeline, __self__).__init__(
|
|
1306
|
+
'gcp:eventarc/pipeline:Pipeline',
|
|
1307
|
+
resource_name,
|
|
1308
|
+
__props__,
|
|
1309
|
+
opts)
|
|
1310
|
+
|
|
1311
|
+
@staticmethod
|
|
1312
|
+
def get(resource_name: str,
|
|
1313
|
+
id: pulumi.Input[str],
|
|
1314
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1315
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1316
|
+
create_time: Optional[pulumi.Input[str]] = None,
|
|
1317
|
+
crypto_key_name: Optional[pulumi.Input[str]] = None,
|
|
1318
|
+
destinations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelineDestinationArgs', 'PipelineDestinationArgsDict']]]]] = None,
|
|
1319
|
+
display_name: Optional[pulumi.Input[str]] = None,
|
|
1320
|
+
effective_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1321
|
+
effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1322
|
+
etag: Optional[pulumi.Input[str]] = None,
|
|
1323
|
+
input_payload_format: Optional[pulumi.Input[Union['PipelineInputPayloadFormatArgs', 'PipelineInputPayloadFormatArgsDict']]] = None,
|
|
1324
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1325
|
+
location: Optional[pulumi.Input[str]] = None,
|
|
1326
|
+
logging_config: Optional[pulumi.Input[Union['PipelineLoggingConfigArgs', 'PipelineLoggingConfigArgsDict']]] = None,
|
|
1327
|
+
mediations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelineMediationArgs', 'PipelineMediationArgsDict']]]]] = None,
|
|
1328
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1329
|
+
pipeline_id: Optional[pulumi.Input[str]] = None,
|
|
1330
|
+
project: Optional[pulumi.Input[str]] = None,
|
|
1331
|
+
pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1332
|
+
retry_policy: Optional[pulumi.Input[Union['PipelineRetryPolicyArgs', 'PipelineRetryPolicyArgsDict']]] = None,
|
|
1333
|
+
uid: Optional[pulumi.Input[str]] = None,
|
|
1334
|
+
update_time: Optional[pulumi.Input[str]] = None) -> 'Pipeline':
|
|
1335
|
+
"""
|
|
1336
|
+
Get an existing Pipeline resource's state with the given name, id, and optional extra
|
|
1337
|
+
properties used to qualify the lookup.
|
|
1338
|
+
|
|
1339
|
+
:param str resource_name: The unique name of the resulting resource.
|
|
1340
|
+
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1341
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1342
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: User-defined annotations. See https://google.aip.dev/128#annotations. **Note**: This field is non-authoritative, and
|
|
1343
|
+
will only manage the annotations present in your configuration. Please refer to the field 'effective_annotations' for
|
|
1344
|
+
all of the annotations present on the resource.
|
|
1345
|
+
:param pulumi.Input[str] create_time: The creation time.
|
|
1346
|
+
A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
|
|
1347
|
+
to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and
|
|
1348
|
+
"2014-10-02T15:01:23.045123456Z".
|
|
1349
|
+
:param pulumi.Input[str] crypto_key_name: Resource name of a KMS crypto key (managed by the user) used to encrypt/decrypt the event data. If not set, an internal
|
|
1350
|
+
Google-owned key will be used to encrypt messages. It must match the pattern
|
|
1351
|
+
"projects/{project}/locations/{location}/keyRings/{keyring}/cryptoKeys/{key}".
|
|
1352
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['PipelineDestinationArgs', 'PipelineDestinationArgsDict']]]] destinations: List of destinations to which messages will be forwarded. Currently,
|
|
1353
|
+
exactly one destination is supported per Pipeline.
|
|
1354
|
+
Structure is documented below.
|
|
1355
|
+
:param pulumi.Input[str] display_name: Display name of resource.
|
|
1356
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] effective_labels: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
|
|
1357
|
+
:param pulumi.Input[str] etag: This checksum is computed by the server based on the value of
|
|
1358
|
+
other fields, and might be sent only on create requests to ensure that the
|
|
1359
|
+
client has an up-to-date value before proceeding.
|
|
1360
|
+
:param pulumi.Input[Union['PipelineInputPayloadFormatArgs', 'PipelineInputPayloadFormatArgsDict']] input_payload_format: Represents the format of message data.
|
|
1361
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: User labels attached to the Pipeline that can be used to group resources. An object containing a list of "key": value
|
|
1362
|
+
pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }. **Note**: This field is non-authoritative, and will
|
|
1363
|
+
only manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
|
|
1364
|
+
present on the resource.
|
|
1365
|
+
:param pulumi.Input[str] location: Resource ID segment making up resource `name`. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
|
|
1366
|
+
:param pulumi.Input[Union['PipelineLoggingConfigArgs', 'PipelineLoggingConfigArgsDict']] logging_config: The configuration for Platform Telemetry logging for Eventarc Advanced resources.
|
|
1367
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['PipelineMediationArgs', 'PipelineMediationArgsDict']]]] mediations: List of mediation operations to be performed on the message. Currently, only one Transformation operation is allowed in
|
|
1368
|
+
each Pipeline.
|
|
1369
|
+
:param pulumi.Input[str] name: The resource name of the Pipeline. Must be unique within the
|
|
1370
|
+
location of the project and must be in
|
|
1371
|
+
`projects/{project}/locations/{location}/pipelines/{pipeline}` format.
|
|
1372
|
+
:param pulumi.Input[str] pipeline_id: The user-provided ID to be assigned to the Pipeline. It should match the
|
|
1373
|
+
format `^a-z?$`.
|
|
1374
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] pulumi_labels: The combination of labels configured directly on the resource
|
|
1375
|
+
and default labels configured on the provider.
|
|
1376
|
+
:param pulumi.Input[Union['PipelineRetryPolicyArgs', 'PipelineRetryPolicyArgsDict']] retry_policy: The retry policy configuration for the Pipeline. The pipeline exponentially backs off in case the destination is non
|
|
1377
|
+
responsive or returns a retryable error code. The default semantics are as follows: The backoff starts with a 5 second
|
|
1378
|
+
delay and doubles the delay after each failed attempt (10 seconds, 20 seconds, 40 seconds, etc.). The delay is capped at
|
|
1379
|
+
60 seconds by default. Please note that if you set the min_retry_delay and max_retry_delay fields to the same value this
|
|
1380
|
+
will make the duration between retries constant.
|
|
1381
|
+
:param pulumi.Input[str] uid: Server-assigned unique identifier for the Pipeline. The value
|
|
1382
|
+
is a UUID4 string and guaranteed to remain unchanged until the resource is
|
|
1383
|
+
deleted.
|
|
1384
|
+
:param pulumi.Input[str] update_time: The last-modified time.
|
|
1385
|
+
A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
|
|
1386
|
+
to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and
|
|
1387
|
+
"2014-10-02T15:01:23.045123456Z".
|
|
1388
|
+
"""
|
|
1389
|
+
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1390
|
+
|
|
1391
|
+
__props__ = _PipelineState.__new__(_PipelineState)
|
|
1392
|
+
|
|
1393
|
+
__props__.__dict__["annotations"] = annotations
|
|
1394
|
+
__props__.__dict__["create_time"] = create_time
|
|
1395
|
+
__props__.__dict__["crypto_key_name"] = crypto_key_name
|
|
1396
|
+
__props__.__dict__["destinations"] = destinations
|
|
1397
|
+
__props__.__dict__["display_name"] = display_name
|
|
1398
|
+
__props__.__dict__["effective_annotations"] = effective_annotations
|
|
1399
|
+
__props__.__dict__["effective_labels"] = effective_labels
|
|
1400
|
+
__props__.__dict__["etag"] = etag
|
|
1401
|
+
__props__.__dict__["input_payload_format"] = input_payload_format
|
|
1402
|
+
__props__.__dict__["labels"] = labels
|
|
1403
|
+
__props__.__dict__["location"] = location
|
|
1404
|
+
__props__.__dict__["logging_config"] = logging_config
|
|
1405
|
+
__props__.__dict__["mediations"] = mediations
|
|
1406
|
+
__props__.__dict__["name"] = name
|
|
1407
|
+
__props__.__dict__["pipeline_id"] = pipeline_id
|
|
1408
|
+
__props__.__dict__["project"] = project
|
|
1409
|
+
__props__.__dict__["pulumi_labels"] = pulumi_labels
|
|
1410
|
+
__props__.__dict__["retry_policy"] = retry_policy
|
|
1411
|
+
__props__.__dict__["uid"] = uid
|
|
1412
|
+
__props__.__dict__["update_time"] = update_time
|
|
1413
|
+
return Pipeline(resource_name, opts=opts, __props__=__props__)
|
|
1414
|
+
|
|
1415
|
+
@property
|
|
1416
|
+
@pulumi.getter
|
|
1417
|
+
def annotations(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
|
|
1418
|
+
"""
|
|
1419
|
+
User-defined annotations. See https://google.aip.dev/128#annotations. **Note**: This field is non-authoritative, and
|
|
1420
|
+
will only manage the annotations present in your configuration. Please refer to the field 'effective_annotations' for
|
|
1421
|
+
all of the annotations present on the resource.
|
|
1422
|
+
"""
|
|
1423
|
+
return pulumi.get(self, "annotations")
|
|
1424
|
+
|
|
1425
|
+
@property
|
|
1426
|
+
@pulumi.getter(name="createTime")
|
|
1427
|
+
def create_time(self) -> pulumi.Output[str]:
|
|
1428
|
+
"""
|
|
1429
|
+
The creation time.
|
|
1430
|
+
A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
|
|
1431
|
+
to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and
|
|
1432
|
+
"2014-10-02T15:01:23.045123456Z".
|
|
1433
|
+
"""
|
|
1434
|
+
return pulumi.get(self, "create_time")
|
|
1435
|
+
|
|
1436
|
+
@property
|
|
1437
|
+
@pulumi.getter(name="cryptoKeyName")
|
|
1438
|
+
def crypto_key_name(self) -> pulumi.Output[Optional[str]]:
|
|
1439
|
+
"""
|
|
1440
|
+
Resource name of a KMS crypto key (managed by the user) used to encrypt/decrypt the event data. If not set, an internal
|
|
1441
|
+
Google-owned key will be used to encrypt messages. It must match the pattern
|
|
1442
|
+
"projects/{project}/locations/{location}/keyRings/{keyring}/cryptoKeys/{key}".
|
|
1443
|
+
"""
|
|
1444
|
+
return pulumi.get(self, "crypto_key_name")
|
|
1445
|
+
|
|
1446
|
+
@property
|
|
1447
|
+
@pulumi.getter
|
|
1448
|
+
def destinations(self) -> pulumi.Output[Sequence['outputs.PipelineDestination']]:
|
|
1449
|
+
"""
|
|
1450
|
+
List of destinations to which messages will be forwarded. Currently,
|
|
1451
|
+
exactly one destination is supported per Pipeline.
|
|
1452
|
+
Structure is documented below.
|
|
1453
|
+
"""
|
|
1454
|
+
return pulumi.get(self, "destinations")
|
|
1455
|
+
|
|
1456
|
+
@property
|
|
1457
|
+
@pulumi.getter(name="displayName")
|
|
1458
|
+
def display_name(self) -> pulumi.Output[Optional[str]]:
|
|
1459
|
+
"""
|
|
1460
|
+
Display name of resource.
|
|
1461
|
+
"""
|
|
1462
|
+
return pulumi.get(self, "display_name")
|
|
1463
|
+
|
|
1464
|
+
@property
|
|
1465
|
+
@pulumi.getter(name="effectiveAnnotations")
|
|
1466
|
+
def effective_annotations(self) -> pulumi.Output[Mapping[str, str]]:
|
|
1467
|
+
return pulumi.get(self, "effective_annotations")
|
|
1468
|
+
|
|
1469
|
+
@property
|
|
1470
|
+
@pulumi.getter(name="effectiveLabels")
|
|
1471
|
+
def effective_labels(self) -> pulumi.Output[Mapping[str, str]]:
|
|
1472
|
+
"""
|
|
1473
|
+
All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
|
|
1474
|
+
"""
|
|
1475
|
+
return pulumi.get(self, "effective_labels")
|
|
1476
|
+
|
|
1477
|
+
@property
|
|
1478
|
+
@pulumi.getter
|
|
1479
|
+
def etag(self) -> pulumi.Output[str]:
|
|
1480
|
+
"""
|
|
1481
|
+
This checksum is computed by the server based on the value of
|
|
1482
|
+
other fields, and might be sent only on create requests to ensure that the
|
|
1483
|
+
client has an up-to-date value before proceeding.
|
|
1484
|
+
"""
|
|
1485
|
+
return pulumi.get(self, "etag")
|
|
1486
|
+
|
|
1487
|
+
@property
|
|
1488
|
+
@pulumi.getter(name="inputPayloadFormat")
|
|
1489
|
+
def input_payload_format(self) -> pulumi.Output[Optional['outputs.PipelineInputPayloadFormat']]:
|
|
1490
|
+
"""
|
|
1491
|
+
Represents the format of message data.
|
|
1492
|
+
"""
|
|
1493
|
+
return pulumi.get(self, "input_payload_format")
|
|
1494
|
+
|
|
1495
|
+
@property
|
|
1496
|
+
@pulumi.getter
|
|
1497
|
+
def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
|
|
1498
|
+
"""
|
|
1499
|
+
User labels attached to the Pipeline that can be used to group resources. An object containing a list of "key": value
|
|
1500
|
+
pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }. **Note**: This field is non-authoritative, and will
|
|
1501
|
+
only manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels
|
|
1502
|
+
present on the resource.
|
|
1503
|
+
"""
|
|
1504
|
+
return pulumi.get(self, "labels")
|
|
1505
|
+
|
|
1506
|
+
@property
|
|
1507
|
+
@pulumi.getter
|
|
1508
|
+
def location(self) -> pulumi.Output[str]:
|
|
1509
|
+
"""
|
|
1510
|
+
Resource ID segment making up resource `name`. It identifies the resource within its parent collection as described in https://google.aip.dev/122.
|
|
1511
|
+
"""
|
|
1512
|
+
return pulumi.get(self, "location")
|
|
1513
|
+
|
|
1514
|
+
@property
|
|
1515
|
+
@pulumi.getter(name="loggingConfig")
|
|
1516
|
+
def logging_config(self) -> pulumi.Output['outputs.PipelineLoggingConfig']:
|
|
1517
|
+
"""
|
|
1518
|
+
The configuration for Platform Telemetry logging for Eventarc Advanced resources.
|
|
1519
|
+
"""
|
|
1520
|
+
return pulumi.get(self, "logging_config")
|
|
1521
|
+
|
|
1522
|
+
@property
|
|
1523
|
+
@pulumi.getter
|
|
1524
|
+
def mediations(self) -> pulumi.Output[Optional[Sequence['outputs.PipelineMediation']]]:
|
|
1525
|
+
"""
|
|
1526
|
+
List of mediation operations to be performed on the message. Currently, only one Transformation operation is allowed in
|
|
1527
|
+
each Pipeline.
|
|
1528
|
+
"""
|
|
1529
|
+
return pulumi.get(self, "mediations")
|
|
1530
|
+
|
|
1531
|
+
@property
|
|
1532
|
+
@pulumi.getter
|
|
1533
|
+
def name(self) -> pulumi.Output[str]:
|
|
1534
|
+
"""
|
|
1535
|
+
The resource name of the Pipeline. Must be unique within the
|
|
1536
|
+
location of the project and must be in
|
|
1537
|
+
`projects/{project}/locations/{location}/pipelines/{pipeline}` format.
|
|
1538
|
+
"""
|
|
1539
|
+
return pulumi.get(self, "name")
|
|
1540
|
+
|
|
1541
|
+
@property
|
|
1542
|
+
@pulumi.getter(name="pipelineId")
|
|
1543
|
+
def pipeline_id(self) -> pulumi.Output[str]:
|
|
1544
|
+
"""
|
|
1545
|
+
The user-provided ID to be assigned to the Pipeline. It should match the
|
|
1546
|
+
format `^a-z?$`.
|
|
1547
|
+
"""
|
|
1548
|
+
return pulumi.get(self, "pipeline_id")
|
|
1549
|
+
|
|
1550
|
+
@property
|
|
1551
|
+
@pulumi.getter
|
|
1552
|
+
def project(self) -> pulumi.Output[str]:
|
|
1553
|
+
return pulumi.get(self, "project")
|
|
1554
|
+
|
|
1555
|
+
@property
|
|
1556
|
+
@pulumi.getter(name="pulumiLabels")
|
|
1557
|
+
def pulumi_labels(self) -> pulumi.Output[Mapping[str, str]]:
|
|
1558
|
+
"""
|
|
1559
|
+
The combination of labels configured directly on the resource
|
|
1560
|
+
and default labels configured on the provider.
|
|
1561
|
+
"""
|
|
1562
|
+
return pulumi.get(self, "pulumi_labels")
|
|
1563
|
+
|
|
1564
|
+
@property
|
|
1565
|
+
@pulumi.getter(name="retryPolicy")
|
|
1566
|
+
def retry_policy(self) -> pulumi.Output['outputs.PipelineRetryPolicy']:
|
|
1567
|
+
"""
|
|
1568
|
+
The retry policy configuration for the Pipeline. The pipeline exponentially backs off in case the destination is non
|
|
1569
|
+
responsive or returns a retryable error code. The default semantics are as follows: The backoff starts with a 5 second
|
|
1570
|
+
delay and doubles the delay after each failed attempt (10 seconds, 20 seconds, 40 seconds, etc.). The delay is capped at
|
|
1571
|
+
60 seconds by default. Please note that if you set the min_retry_delay and max_retry_delay fields to the same value this
|
|
1572
|
+
will make the duration between retries constant.
|
|
1573
|
+
"""
|
|
1574
|
+
return pulumi.get(self, "retry_policy")
|
|
1575
|
+
|
|
1576
|
+
@property
|
|
1577
|
+
@pulumi.getter
|
|
1578
|
+
def uid(self) -> pulumi.Output[str]:
|
|
1579
|
+
"""
|
|
1580
|
+
Server-assigned unique identifier for the Pipeline. The value
|
|
1581
|
+
is a UUID4 string and guaranteed to remain unchanged until the resource is
|
|
1582
|
+
deleted.
|
|
1583
|
+
"""
|
|
1584
|
+
return pulumi.get(self, "uid")
|
|
1585
|
+
|
|
1586
|
+
@property
|
|
1587
|
+
@pulumi.getter(name="updateTime")
|
|
1588
|
+
def update_time(self) -> pulumi.Output[str]:
|
|
1589
|
+
"""
|
|
1590
|
+
The last-modified time.
|
|
1591
|
+
A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up
|
|
1592
|
+
to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and
|
|
1593
|
+
"2014-10-02T15:01:23.045123456Z".
|
|
1594
|
+
"""
|
|
1595
|
+
return pulumi.get(self, "update_time")
|
|
1596
|
+
|