pulumi-gcp 7.30.0__py3-none-any.whl → 7.30.0a1719513455__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 +0 -32
- pulumi_gcp/artifactregistry/get_docker_image.py +2 -2
- pulumi_gcp/bigtable/gc_policy.py +14 -68
- pulumi_gcp/cloudfunctionsv2/_inputs.py +0 -97
- pulumi_gcp/cloudfunctionsv2/function.py +0 -232
- pulumi_gcp/cloudfunctionsv2/outputs.py +1 -129
- pulumi_gcp/compute/_inputs.py +0 -622
- pulumi_gcp/compute/address.py +7 -0
- pulumi_gcp/compute/backend_service.py +14 -0
- pulumi_gcp/compute/forwarding_rule.py +21 -0
- pulumi_gcp/compute/global_forwarding_rule.py +21 -0
- pulumi_gcp/compute/managed_ssl_certificate.py +7 -0
- pulumi_gcp/compute/manged_ssl_certificate.py +7 -0
- pulumi_gcp/compute/network_attachment.py +0 -16
- pulumi_gcp/compute/outputs.py +8 -504
- pulumi_gcp/compute/region_backend_service.py +14 -0
- pulumi_gcp/compute/region_disk_iam_binding.py +95 -122
- pulumi_gcp/compute/region_disk_iam_member.py +95 -122
- pulumi_gcp/compute/region_disk_iam_policy.py +88 -115
- pulumi_gcp/compute/region_ssl_certificate.py +7 -0
- pulumi_gcp/compute/ssl_certificate.py +7 -0
- pulumi_gcp/compute/target_https_proxy.py +1 -76
- pulumi_gcp/compute/url_map.py +0 -255
- pulumi_gcp/container/aws_cluster.py +2 -2
- pulumi_gcp/container/aws_node_pool.py +2 -2
- pulumi_gcp/container/azure_client.py +2 -2
- pulumi_gcp/container/azure_cluster.py +2 -2
- pulumi_gcp/container/azure_node_pool.py +2 -2
- pulumi_gcp/datafusion/_inputs.py +11 -163
- pulumi_gcp/datafusion/instance.py +0 -64
- pulumi_gcp/datafusion/outputs.py +7 -127
- pulumi_gcp/gkebackup/restore_plan_iam_binding.py +953 -328
- pulumi_gcp/gkebackup/restore_plan_iam_member.py +953 -328
- pulumi_gcp/gkebackup/restore_plan_iam_policy.py +953 -238
- pulumi_gcp/healthcare/_inputs.py +0 -43
- pulumi_gcp/healthcare/dataset.py +0 -110
- pulumi_gcp/healthcare/outputs.py +0 -43
- pulumi_gcp/identityplatform/config.py +1 -1
- pulumi_gcp/logging/billing_account_bucket_config.py +1 -1
- pulumi_gcp/logging/folder_bucket_config.py +1 -1
- pulumi_gcp/logging/organization_bucket_config.py +1 -1
- pulumi_gcp/monitoring/_inputs.py +0 -77
- pulumi_gcp/monitoring/outputs.py +0 -63
- pulumi_gcp/networksecurity/address_group_iam_binding.py +2 -289
- pulumi_gcp/networksecurity/address_group_iam_member.py +2 -289
- pulumi_gcp/pulumi-plugin.json +1 -1
- pulumi_gcp/securitycenter/instance_iam_binding.py +0 -64
- pulumi_gcp/securitycenter/instance_iam_member.py +0 -64
- pulumi_gcp/securitycenter/instance_iam_policy.py +0 -64
- pulumi_gcp/sourcerepo/repository_iam_binding.py +83 -92
- pulumi_gcp/sourcerepo/repository_iam_member.py +83 -92
- pulumi_gcp/sourcerepo/repository_iam_policy.py +76 -85
- pulumi_gcp/storage/__init__.py +0 -5
- pulumi_gcp/storage/_inputs.py +0 -130
- pulumi_gcp/storage/outputs.py +0 -76
- pulumi_gcp/vertex/_inputs.py +3 -3
- pulumi_gcp/vertex/ai_feature_online_store.py +9 -9
- pulumi_gcp/vertex/outputs.py +2 -2
- {pulumi_gcp-7.30.0.dist-info → pulumi_gcp-7.30.0a1719513455.dist-info}/METADATA +1 -1
- {pulumi_gcp-7.30.0.dist-info → pulumi_gcp-7.30.0a1719513455.dist-info}/RECORD +62 -67
- {pulumi_gcp-7.30.0.dist-info → pulumi_gcp-7.30.0a1719513455.dist-info}/WHEEL +1 -1
- pulumi_gcp/storage/get_managed_folder_iam_policy.py +0 -115
- pulumi_gcp/storage/managed_folder.py +0 -440
- pulumi_gcp/storage/managed_folder_iam_binding.py +0 -947
- pulumi_gcp/storage/managed_folder_iam_member.py +0 -947
- pulumi_gcp/storage/managed_folder_iam_policy.py +0 -766
- {pulumi_gcp-7.30.0.dist-info → pulumi_gcp-7.30.0a1719513455.dist-info}/top_level.txt +0 -0
|
@@ -29,27 +29,8 @@ class RestorePlanIamMemberArgs:
|
|
|
29
29
|
project: Optional[pulumi.Input[str]] = None):
|
|
30
30
|
"""
|
|
31
31
|
The set of arguments for constructing a RestorePlanIamMember resource.
|
|
32
|
-
:param pulumi.Input[str] member: Identities that will be granted the privilege in `role`.
|
|
33
|
-
Each entry can have one of the following values:
|
|
34
|
-
* **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
|
|
35
|
-
* **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
|
|
36
|
-
* **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
|
|
37
|
-
* **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
|
|
38
|
-
* **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
|
|
39
|
-
* **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
|
|
40
|
-
* **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
|
|
41
|
-
* **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
|
|
42
|
-
* **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
|
|
43
|
-
:param pulumi.Input[str] role: The role that should be applied. Only one
|
|
44
|
-
`gkebackup.RestorePlanIamBinding` can be used per role. Note that custom roles must be of the format
|
|
45
|
-
`[projects|organizations]/{parent-name}/roles/{role-name}`.
|
|
46
32
|
:param pulumi.Input[str] location: The region of the Restore Plan.
|
|
47
|
-
|
|
48
|
-
the value will be parsed from the identifier of the parent resource. If no location is provided in the parent identifier and no
|
|
49
|
-
location is specified, it is taken from the provider configuration.
|
|
50
|
-
:param pulumi.Input[str] name: Used to find the parent resource to bind the IAM policy to
|
|
51
|
-
:param pulumi.Input[str] project: The ID of the project in which the resource belongs.
|
|
52
|
-
If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
|
|
33
|
+
:param pulumi.Input[str] name: The full name of the BackupPlan Resource.
|
|
53
34
|
"""
|
|
54
35
|
pulumi.set(__self__, "member", member)
|
|
55
36
|
pulumi.set(__self__, "role", role)
|
|
@@ -65,19 +46,6 @@ class RestorePlanIamMemberArgs:
|
|
|
65
46
|
@property
|
|
66
47
|
@pulumi.getter
|
|
67
48
|
def member(self) -> pulumi.Input[str]:
|
|
68
|
-
"""
|
|
69
|
-
Identities that will be granted the privilege in `role`.
|
|
70
|
-
Each entry can have one of the following values:
|
|
71
|
-
* **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
|
|
72
|
-
* **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
|
|
73
|
-
* **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
|
|
74
|
-
* **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
|
|
75
|
-
* **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
|
|
76
|
-
* **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
|
|
77
|
-
* **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
|
|
78
|
-
* **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
|
|
79
|
-
* **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
|
|
80
|
-
"""
|
|
81
49
|
return pulumi.get(self, "member")
|
|
82
50
|
|
|
83
51
|
@member.setter
|
|
@@ -87,11 +55,6 @@ class RestorePlanIamMemberArgs:
|
|
|
87
55
|
@property
|
|
88
56
|
@pulumi.getter
|
|
89
57
|
def role(self) -> pulumi.Input[str]:
|
|
90
|
-
"""
|
|
91
|
-
The role that should be applied. Only one
|
|
92
|
-
`gkebackup.RestorePlanIamBinding` can be used per role. Note that custom roles must be of the format
|
|
93
|
-
`[projects|organizations]/{parent-name}/roles/{role-name}`.
|
|
94
|
-
"""
|
|
95
58
|
return pulumi.get(self, "role")
|
|
96
59
|
|
|
97
60
|
@role.setter
|
|
@@ -112,9 +75,6 @@ class RestorePlanIamMemberArgs:
|
|
|
112
75
|
def location(self) -> Optional[pulumi.Input[str]]:
|
|
113
76
|
"""
|
|
114
77
|
The region of the Restore Plan.
|
|
115
|
-
Used to find the parent resource to bind the IAM policy to. If not specified,
|
|
116
|
-
the value will be parsed from the identifier of the parent resource. If no location is provided in the parent identifier and no
|
|
117
|
-
location is specified, it is taken from the provider configuration.
|
|
118
78
|
"""
|
|
119
79
|
return pulumi.get(self, "location")
|
|
120
80
|
|
|
@@ -126,7 +86,7 @@ class RestorePlanIamMemberArgs:
|
|
|
126
86
|
@pulumi.getter
|
|
127
87
|
def name(self) -> Optional[pulumi.Input[str]]:
|
|
128
88
|
"""
|
|
129
|
-
|
|
89
|
+
The full name of the BackupPlan Resource.
|
|
130
90
|
"""
|
|
131
91
|
return pulumi.get(self, "name")
|
|
132
92
|
|
|
@@ -137,10 +97,6 @@ class RestorePlanIamMemberArgs:
|
|
|
137
97
|
@property
|
|
138
98
|
@pulumi.getter
|
|
139
99
|
def project(self) -> Optional[pulumi.Input[str]]:
|
|
140
|
-
"""
|
|
141
|
-
The ID of the project in which the resource belongs.
|
|
142
|
-
If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
|
|
143
|
-
"""
|
|
144
100
|
return pulumi.get(self, "project")
|
|
145
101
|
|
|
146
102
|
@project.setter
|
|
@@ -160,28 +116,8 @@ class _RestorePlanIamMemberState:
|
|
|
160
116
|
role: Optional[pulumi.Input[str]] = None):
|
|
161
117
|
"""
|
|
162
118
|
Input properties used for looking up and filtering RestorePlanIamMember resources.
|
|
163
|
-
:param pulumi.Input[str] etag: (Computed) The etag of the IAM policy.
|
|
164
119
|
:param pulumi.Input[str] location: The region of the Restore Plan.
|
|
165
|
-
|
|
166
|
-
the value will be parsed from the identifier of the parent resource. If no location is provided in the parent identifier and no
|
|
167
|
-
location is specified, it is taken from the provider configuration.
|
|
168
|
-
:param pulumi.Input[str] member: Identities that will be granted the privilege in `role`.
|
|
169
|
-
Each entry can have one of the following values:
|
|
170
|
-
* **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
|
|
171
|
-
* **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
|
|
172
|
-
* **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
|
|
173
|
-
* **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
|
|
174
|
-
* **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
|
|
175
|
-
* **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
|
|
176
|
-
* **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
|
|
177
|
-
* **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
|
|
178
|
-
* **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
|
|
179
|
-
:param pulumi.Input[str] name: Used to find the parent resource to bind the IAM policy to
|
|
180
|
-
:param pulumi.Input[str] project: The ID of the project in which the resource belongs.
|
|
181
|
-
If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
|
|
182
|
-
:param pulumi.Input[str] role: The role that should be applied. Only one
|
|
183
|
-
`gkebackup.RestorePlanIamBinding` can be used per role. Note that custom roles must be of the format
|
|
184
|
-
`[projects|organizations]/{parent-name}/roles/{role-name}`.
|
|
120
|
+
:param pulumi.Input[str] name: The full name of the BackupPlan Resource.
|
|
185
121
|
"""
|
|
186
122
|
if condition is not None:
|
|
187
123
|
pulumi.set(__self__, "condition", condition)
|
|
@@ -210,9 +146,6 @@ class _RestorePlanIamMemberState:
|
|
|
210
146
|
@property
|
|
211
147
|
@pulumi.getter
|
|
212
148
|
def etag(self) -> Optional[pulumi.Input[str]]:
|
|
213
|
-
"""
|
|
214
|
-
(Computed) The etag of the IAM policy.
|
|
215
|
-
"""
|
|
216
149
|
return pulumi.get(self, "etag")
|
|
217
150
|
|
|
218
151
|
@etag.setter
|
|
@@ -224,9 +157,6 @@ class _RestorePlanIamMemberState:
|
|
|
224
157
|
def location(self) -> Optional[pulumi.Input[str]]:
|
|
225
158
|
"""
|
|
226
159
|
The region of the Restore Plan.
|
|
227
|
-
Used to find the parent resource to bind the IAM policy to. If not specified,
|
|
228
|
-
the value will be parsed from the identifier of the parent resource. If no location is provided in the parent identifier and no
|
|
229
|
-
location is specified, it is taken from the provider configuration.
|
|
230
160
|
"""
|
|
231
161
|
return pulumi.get(self, "location")
|
|
232
162
|
|
|
@@ -237,19 +167,6 @@ class _RestorePlanIamMemberState:
|
|
|
237
167
|
@property
|
|
238
168
|
@pulumi.getter
|
|
239
169
|
def member(self) -> Optional[pulumi.Input[str]]:
|
|
240
|
-
"""
|
|
241
|
-
Identities that will be granted the privilege in `role`.
|
|
242
|
-
Each entry can have one of the following values:
|
|
243
|
-
* **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
|
|
244
|
-
* **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
|
|
245
|
-
* **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
|
|
246
|
-
* **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
|
|
247
|
-
* **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
|
|
248
|
-
* **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
|
|
249
|
-
* **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
|
|
250
|
-
* **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
|
|
251
|
-
* **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
|
|
252
|
-
"""
|
|
253
170
|
return pulumi.get(self, "member")
|
|
254
171
|
|
|
255
172
|
@member.setter
|
|
@@ -260,7 +177,7 @@ class _RestorePlanIamMemberState:
|
|
|
260
177
|
@pulumi.getter
|
|
261
178
|
def name(self) -> Optional[pulumi.Input[str]]:
|
|
262
179
|
"""
|
|
263
|
-
|
|
180
|
+
The full name of the BackupPlan Resource.
|
|
264
181
|
"""
|
|
265
182
|
return pulumi.get(self, "name")
|
|
266
183
|
|
|
@@ -271,10 +188,6 @@ class _RestorePlanIamMemberState:
|
|
|
271
188
|
@property
|
|
272
189
|
@pulumi.getter
|
|
273
190
|
def project(self) -> Optional[pulumi.Input[str]]:
|
|
274
|
-
"""
|
|
275
|
-
The ID of the project in which the resource belongs.
|
|
276
|
-
If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
|
|
277
|
-
"""
|
|
278
191
|
return pulumi.get(self, "project")
|
|
279
192
|
|
|
280
193
|
@project.setter
|
|
@@ -284,11 +197,6 @@ class _RestorePlanIamMemberState:
|
|
|
284
197
|
@property
|
|
285
198
|
@pulumi.getter
|
|
286
199
|
def role(self) -> Optional[pulumi.Input[str]]:
|
|
287
|
-
"""
|
|
288
|
-
The role that should be applied. Only one
|
|
289
|
-
`gkebackup.RestorePlanIamBinding` can be used per role. Note that custom roles must be of the format
|
|
290
|
-
`[projects|organizations]/{parent-name}/roles/{role-name}`.
|
|
291
|
-
"""
|
|
292
200
|
return pulumi.get(self, "role")
|
|
293
201
|
|
|
294
202
|
@role.setter
|
|
@@ -309,171 +217,544 @@ class RestorePlanIamMember(pulumi.CustomResource):
|
|
|
309
217
|
role: Optional[pulumi.Input[str]] = None,
|
|
310
218
|
__props__=None):
|
|
311
219
|
"""
|
|
312
|
-
|
|
220
|
+
Represents a Restore Plan instance.
|
|
313
221
|
|
|
314
|
-
|
|
315
|
-
* `gkebackup.RestorePlanIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the restoreplan are preserved.
|
|
316
|
-
* `gkebackup.RestorePlanIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the restoreplan are preserved.
|
|
222
|
+
To get more information about RestorePlan, see:
|
|
317
223
|
|
|
318
|
-
|
|
224
|
+
* [API documentation](https://cloud.google.com/kubernetes-engine/docs/add-on/backup-for-gke/reference/rest/v1/projects.locations.restorePlans)
|
|
225
|
+
* How-to Guides
|
|
226
|
+
* [Official Documentation](https://cloud.google.com/kubernetes-engine/docs/add-on/backup-for-gke)
|
|
319
227
|
|
|
320
|
-
|
|
228
|
+
## Example Usage
|
|
321
229
|
|
|
322
|
-
|
|
230
|
+
### Gkebackup Restoreplan All Namespaces
|
|
323
231
|
|
|
324
|
-
|
|
232
|
+
```python
|
|
233
|
+
import pulumi
|
|
234
|
+
import pulumi_gcp as gcp
|
|
325
235
|
|
|
326
|
-
|
|
236
|
+
primary = gcp.container.Cluster("primary",
|
|
237
|
+
name="restore-all-ns-cluster",
|
|
238
|
+
location="us-central1",
|
|
239
|
+
initial_node_count=1,
|
|
240
|
+
workload_identity_config={
|
|
241
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
242
|
+
},
|
|
243
|
+
addons_config={
|
|
244
|
+
"gkeBackupAgentConfig": {
|
|
245
|
+
"enabled": True,
|
|
246
|
+
},
|
|
247
|
+
},
|
|
248
|
+
deletion_protection="",
|
|
249
|
+
network="default",
|
|
250
|
+
subnetwork="default")
|
|
251
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
252
|
+
name="restore-all-ns",
|
|
253
|
+
cluster=primary.id,
|
|
254
|
+
location="us-central1",
|
|
255
|
+
backup_config={
|
|
256
|
+
"includeVolumeData": True,
|
|
257
|
+
"includeSecrets": True,
|
|
258
|
+
"allNamespaces": True,
|
|
259
|
+
})
|
|
260
|
+
all_ns = gcp.gkebackup.RestorePlan("all_ns",
|
|
261
|
+
name="restore-all-ns",
|
|
262
|
+
location="us-central1",
|
|
263
|
+
backup_plan=basic.id,
|
|
264
|
+
cluster=primary.id,
|
|
265
|
+
restore_config={
|
|
266
|
+
"allNamespaces": True,
|
|
267
|
+
"namespacedResourceRestoreMode": "FAIL_ON_CONFLICT",
|
|
268
|
+
"volumeDataRestorePolicy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
269
|
+
"clusterResourceRestoreScope": {
|
|
270
|
+
"allGroupKinds": True,
|
|
271
|
+
},
|
|
272
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
273
|
+
})
|
|
274
|
+
```
|
|
275
|
+
### Gkebackup Restoreplan Rollback Namespace
|
|
327
276
|
|
|
328
277
|
```python
|
|
329
278
|
import pulumi
|
|
330
279
|
import pulumi_gcp as gcp
|
|
331
280
|
|
|
332
|
-
|
|
333
|
-
"
|
|
334
|
-
"
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
281
|
+
primary = gcp.container.Cluster("primary",
|
|
282
|
+
name="rollback-ns-cluster",
|
|
283
|
+
location="us-central1",
|
|
284
|
+
initial_node_count=1,
|
|
285
|
+
workload_identity_config={
|
|
286
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
287
|
+
},
|
|
288
|
+
addons_config={
|
|
289
|
+
"gkeBackupAgentConfig": {
|
|
290
|
+
"enabled": True,
|
|
291
|
+
},
|
|
292
|
+
},
|
|
293
|
+
deletion_protection="",
|
|
294
|
+
network="default",
|
|
295
|
+
subnetwork="default")
|
|
296
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
297
|
+
name="rollback-ns",
|
|
298
|
+
cluster=primary.id,
|
|
299
|
+
location="us-central1",
|
|
300
|
+
backup_config={
|
|
301
|
+
"includeVolumeData": True,
|
|
302
|
+
"includeSecrets": True,
|
|
303
|
+
"allNamespaces": True,
|
|
304
|
+
})
|
|
305
|
+
rollback_ns = gcp.gkebackup.RestorePlan("rollback_ns",
|
|
306
|
+
name="rollback-ns-rp",
|
|
307
|
+
location="us-central1",
|
|
308
|
+
backup_plan=basic.id,
|
|
309
|
+
cluster=primary.id,
|
|
310
|
+
restore_config={
|
|
311
|
+
"selectedNamespaces": {
|
|
312
|
+
"namespaces": ["my-ns"],
|
|
313
|
+
},
|
|
314
|
+
"namespacedResourceRestoreMode": "DELETE_AND_RESTORE",
|
|
315
|
+
"volumeDataRestorePolicy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
316
|
+
"clusterResourceRestoreScope": {
|
|
317
|
+
"selectedGroupKinds": [
|
|
318
|
+
{
|
|
319
|
+
"resourceGroup": "apiextension.k8s.io",
|
|
320
|
+
"resourceKind": "CustomResourceDefinition",
|
|
321
|
+
},
|
|
322
|
+
{
|
|
323
|
+
"resourceGroup": "storage.k8s.io",
|
|
324
|
+
"resourceKind": "StorageClass",
|
|
325
|
+
},
|
|
326
|
+
],
|
|
327
|
+
},
|
|
328
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
329
|
+
})
|
|
341
330
|
```
|
|
342
|
-
|
|
343
|
-
## gkebackup.RestorePlanIamBinding
|
|
331
|
+
### Gkebackup Restoreplan Protected Application
|
|
344
332
|
|
|
345
333
|
```python
|
|
346
334
|
import pulumi
|
|
347
335
|
import pulumi_gcp as gcp
|
|
348
336
|
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
location=
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
337
|
+
primary = gcp.container.Cluster("primary",
|
|
338
|
+
name="rollback-app-cluster",
|
|
339
|
+
location="us-central1",
|
|
340
|
+
initial_node_count=1,
|
|
341
|
+
workload_identity_config={
|
|
342
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
343
|
+
},
|
|
344
|
+
addons_config={
|
|
345
|
+
"gkeBackupAgentConfig": {
|
|
346
|
+
"enabled": True,
|
|
347
|
+
},
|
|
348
|
+
},
|
|
349
|
+
deletion_protection="",
|
|
350
|
+
network="default",
|
|
351
|
+
subnetwork="default")
|
|
352
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
353
|
+
name="rollback-app",
|
|
354
|
+
cluster=primary.id,
|
|
355
|
+
location="us-central1",
|
|
356
|
+
backup_config={
|
|
357
|
+
"includeVolumeData": True,
|
|
358
|
+
"includeSecrets": True,
|
|
359
|
+
"allNamespaces": True,
|
|
360
|
+
})
|
|
361
|
+
rollback_app = gcp.gkebackup.RestorePlan("rollback_app",
|
|
362
|
+
name="rollback-app-rp",
|
|
363
|
+
location="us-central1",
|
|
364
|
+
backup_plan=basic.id,
|
|
365
|
+
cluster=primary.id,
|
|
366
|
+
restore_config={
|
|
367
|
+
"selectedApplications": {
|
|
368
|
+
"namespacedNames": [{
|
|
369
|
+
"name": "my-app",
|
|
370
|
+
"namespace": "my-ns",
|
|
371
|
+
}],
|
|
372
|
+
},
|
|
373
|
+
"namespacedResourceRestoreMode": "DELETE_AND_RESTORE",
|
|
374
|
+
"volumeDataRestorePolicy": "REUSE_VOLUME_HANDLE_FROM_BACKUP",
|
|
375
|
+
"clusterResourceRestoreScope": {
|
|
376
|
+
"noGroupKinds": True,
|
|
377
|
+
},
|
|
378
|
+
})
|
|
355
379
|
```
|
|
356
|
-
|
|
357
|
-
## gkebackup.RestorePlanIamMember
|
|
380
|
+
### Gkebackup Restoreplan All Cluster Resources
|
|
358
381
|
|
|
359
382
|
```python
|
|
360
383
|
import pulumi
|
|
361
384
|
import pulumi_gcp as gcp
|
|
362
385
|
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
location=
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
386
|
+
primary = gcp.container.Cluster("primary",
|
|
387
|
+
name="all-groupkinds-cluster",
|
|
388
|
+
location="us-central1",
|
|
389
|
+
initial_node_count=1,
|
|
390
|
+
workload_identity_config={
|
|
391
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
392
|
+
},
|
|
393
|
+
addons_config={
|
|
394
|
+
"gkeBackupAgentConfig": {
|
|
395
|
+
"enabled": True,
|
|
396
|
+
},
|
|
397
|
+
},
|
|
398
|
+
deletion_protection="",
|
|
399
|
+
network="default",
|
|
400
|
+
subnetwork="default")
|
|
401
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
402
|
+
name="all-groupkinds",
|
|
403
|
+
cluster=primary.id,
|
|
404
|
+
location="us-central1",
|
|
405
|
+
backup_config={
|
|
406
|
+
"includeVolumeData": True,
|
|
407
|
+
"includeSecrets": True,
|
|
408
|
+
"allNamespaces": True,
|
|
409
|
+
})
|
|
410
|
+
all_cluster_resources = gcp.gkebackup.RestorePlan("all_cluster_resources",
|
|
411
|
+
name="all-groupkinds-rp",
|
|
412
|
+
location="us-central1",
|
|
413
|
+
backup_plan=basic.id,
|
|
414
|
+
cluster=primary.id,
|
|
415
|
+
restore_config={
|
|
416
|
+
"noNamespaces": True,
|
|
417
|
+
"namespacedResourceRestoreMode": "FAIL_ON_CONFLICT",
|
|
418
|
+
"clusterResourceRestoreScope": {
|
|
419
|
+
"allGroupKinds": True,
|
|
420
|
+
},
|
|
421
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
422
|
+
})
|
|
369
423
|
```
|
|
370
|
-
|
|
371
|
-
## gkebackup.RestorePlanIamPolicy
|
|
424
|
+
### Gkebackup Restoreplan Rename Namespace
|
|
372
425
|
|
|
373
426
|
```python
|
|
374
427
|
import pulumi
|
|
375
428
|
import pulumi_gcp as gcp
|
|
376
429
|
|
|
377
|
-
|
|
378
|
-
"
|
|
379
|
-
"
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
430
|
+
primary = gcp.container.Cluster("primary",
|
|
431
|
+
name="rename-ns-cluster",
|
|
432
|
+
location="us-central1",
|
|
433
|
+
initial_node_count=1,
|
|
434
|
+
workload_identity_config={
|
|
435
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
436
|
+
},
|
|
437
|
+
addons_config={
|
|
438
|
+
"gkeBackupAgentConfig": {
|
|
439
|
+
"enabled": True,
|
|
440
|
+
},
|
|
441
|
+
},
|
|
442
|
+
deletion_protection="",
|
|
443
|
+
network="default",
|
|
444
|
+
subnetwork="default")
|
|
445
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
446
|
+
name="rename-ns",
|
|
447
|
+
cluster=primary.id,
|
|
448
|
+
location="us-central1",
|
|
449
|
+
backup_config={
|
|
450
|
+
"includeVolumeData": True,
|
|
451
|
+
"includeSecrets": True,
|
|
452
|
+
"allNamespaces": True,
|
|
453
|
+
})
|
|
454
|
+
rename_ns = gcp.gkebackup.RestorePlan("rename_ns",
|
|
455
|
+
name="rename-ns-rp",
|
|
456
|
+
location="us-central1",
|
|
457
|
+
backup_plan=basic.id,
|
|
458
|
+
cluster=primary.id,
|
|
459
|
+
restore_config={
|
|
460
|
+
"selectedNamespaces": {
|
|
461
|
+
"namespaces": ["ns1"],
|
|
462
|
+
},
|
|
463
|
+
"namespacedResourceRestoreMode": "FAIL_ON_CONFLICT",
|
|
464
|
+
"volumeDataRestorePolicy": "REUSE_VOLUME_HANDLE_FROM_BACKUP",
|
|
465
|
+
"clusterResourceRestoreScope": {
|
|
466
|
+
"noGroupKinds": True,
|
|
467
|
+
},
|
|
468
|
+
"transformationRules": [
|
|
469
|
+
{
|
|
470
|
+
"description": "rename namespace from ns1 to ns2",
|
|
471
|
+
"resourceFilter": {
|
|
472
|
+
"groupKinds": [{
|
|
473
|
+
"resourceKind": "Namespace",
|
|
474
|
+
}],
|
|
475
|
+
"jsonPath": ".metadata[?(@.name == 'ns1')]",
|
|
476
|
+
},
|
|
477
|
+
"fieldActions": [{
|
|
478
|
+
"op": "REPLACE",
|
|
479
|
+
"path": "/metadata/name",
|
|
480
|
+
"value": "ns2",
|
|
481
|
+
}],
|
|
482
|
+
},
|
|
483
|
+
{
|
|
484
|
+
"description": "move all resources from ns1 to ns2",
|
|
485
|
+
"resourceFilter": {
|
|
486
|
+
"namespaces": ["ns1"],
|
|
487
|
+
},
|
|
488
|
+
"fieldActions": [{
|
|
489
|
+
"op": "REPLACE",
|
|
490
|
+
"path": "/metadata/namespace",
|
|
491
|
+
"value": "ns2",
|
|
492
|
+
}],
|
|
493
|
+
},
|
|
494
|
+
],
|
|
495
|
+
})
|
|
386
496
|
```
|
|
387
|
-
|
|
388
|
-
## gkebackup.RestorePlanIamBinding
|
|
497
|
+
### Gkebackup Restoreplan Second Transformation
|
|
389
498
|
|
|
390
499
|
```python
|
|
391
500
|
import pulumi
|
|
392
501
|
import pulumi_gcp as gcp
|
|
393
502
|
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
location=
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
503
|
+
primary = gcp.container.Cluster("primary",
|
|
504
|
+
name="transform-rule-cluster",
|
|
505
|
+
location="us-central1",
|
|
506
|
+
initial_node_count=1,
|
|
507
|
+
workload_identity_config={
|
|
508
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
509
|
+
},
|
|
510
|
+
addons_config={
|
|
511
|
+
"gkeBackupAgentConfig": {
|
|
512
|
+
"enabled": True,
|
|
513
|
+
},
|
|
514
|
+
},
|
|
515
|
+
deletion_protection="",
|
|
516
|
+
network="default",
|
|
517
|
+
subnetwork="default")
|
|
518
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
519
|
+
name="transform-rule",
|
|
520
|
+
cluster=primary.id,
|
|
521
|
+
location="us-central1",
|
|
522
|
+
backup_config={
|
|
523
|
+
"includeVolumeData": True,
|
|
524
|
+
"includeSecrets": True,
|
|
525
|
+
"allNamespaces": True,
|
|
526
|
+
})
|
|
527
|
+
transform_rule = gcp.gkebackup.RestorePlan("transform_rule",
|
|
528
|
+
name="transform-rule-rp",
|
|
529
|
+
description="copy nginx env variables",
|
|
530
|
+
labels={
|
|
531
|
+
"app": "nginx",
|
|
532
|
+
},
|
|
533
|
+
location="us-central1",
|
|
534
|
+
backup_plan=basic.id,
|
|
535
|
+
cluster=primary.id,
|
|
536
|
+
restore_config={
|
|
537
|
+
"excludedNamespaces": {
|
|
538
|
+
"namespaces": ["my-ns"],
|
|
539
|
+
},
|
|
540
|
+
"namespacedResourceRestoreMode": "DELETE_AND_RESTORE",
|
|
541
|
+
"volumeDataRestorePolicy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
542
|
+
"clusterResourceRestoreScope": {
|
|
543
|
+
"excludedGroupKinds": [{
|
|
544
|
+
"resourceGroup": "apiextension.k8s.io",
|
|
545
|
+
"resourceKind": "CustomResourceDefinition",
|
|
546
|
+
}],
|
|
547
|
+
},
|
|
548
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
549
|
+
"transformationRules": [{
|
|
550
|
+
"description": "Copy environment variables from the nginx container to the install init container.",
|
|
551
|
+
"resourceFilter": {
|
|
552
|
+
"groupKinds": [{
|
|
553
|
+
"resourceKind": "Pod",
|
|
554
|
+
"resourceGroup": "",
|
|
555
|
+
}],
|
|
556
|
+
"jsonPath": ".metadata[?(@.name == 'nginx')]",
|
|
557
|
+
},
|
|
558
|
+
"fieldActions": [{
|
|
559
|
+
"op": "COPY",
|
|
560
|
+
"path": "/spec/initContainers/0/env",
|
|
561
|
+
"fromPath": "/spec/containers/0/env",
|
|
562
|
+
}],
|
|
563
|
+
}],
|
|
564
|
+
})
|
|
400
565
|
```
|
|
401
|
-
|
|
402
|
-
## gkebackup.RestorePlanIamMember
|
|
566
|
+
### Gkebackup Restoreplan Gitops Mode
|
|
403
567
|
|
|
404
568
|
```python
|
|
405
569
|
import pulumi
|
|
406
570
|
import pulumi_gcp as gcp
|
|
407
571
|
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
location=
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
572
|
+
primary = gcp.container.Cluster("primary",
|
|
573
|
+
name="gitops-mode-cluster",
|
|
574
|
+
location="us-central1",
|
|
575
|
+
initial_node_count=1,
|
|
576
|
+
workload_identity_config={
|
|
577
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
578
|
+
},
|
|
579
|
+
addons_config={
|
|
580
|
+
"gkeBackupAgentConfig": {
|
|
581
|
+
"enabled": True,
|
|
582
|
+
},
|
|
583
|
+
},
|
|
584
|
+
deletion_protection="",
|
|
585
|
+
network="default",
|
|
586
|
+
subnetwork="default")
|
|
587
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
588
|
+
name="gitops-mode",
|
|
589
|
+
cluster=primary.id,
|
|
590
|
+
location="us-central1",
|
|
591
|
+
backup_config={
|
|
592
|
+
"includeVolumeData": True,
|
|
593
|
+
"includeSecrets": True,
|
|
594
|
+
"allNamespaces": True,
|
|
595
|
+
})
|
|
596
|
+
gitops_mode = gcp.gkebackup.RestorePlan("gitops_mode",
|
|
597
|
+
name="gitops-mode",
|
|
598
|
+
location="us-central1",
|
|
599
|
+
backup_plan=basic.id,
|
|
600
|
+
cluster=primary.id,
|
|
601
|
+
restore_config={
|
|
602
|
+
"allNamespaces": True,
|
|
603
|
+
"namespacedResourceRestoreMode": "MERGE_SKIP_ON_CONFLICT",
|
|
604
|
+
"volumeDataRestorePolicy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
605
|
+
"clusterResourceRestoreScope": {
|
|
606
|
+
"allGroupKinds": True,
|
|
607
|
+
},
|
|
608
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
609
|
+
})
|
|
414
610
|
```
|
|
611
|
+
### Gkebackup Restoreplan Restore Order
|
|
415
612
|
|
|
416
|
-
|
|
613
|
+
```python
|
|
614
|
+
import pulumi
|
|
615
|
+
import pulumi_gcp as gcp
|
|
417
616
|
|
|
418
|
-
|
|
617
|
+
primary = gcp.container.Cluster("primary",
|
|
618
|
+
name="restore-order-cluster",
|
|
619
|
+
location="us-central1",
|
|
620
|
+
initial_node_count=1,
|
|
621
|
+
workload_identity_config={
|
|
622
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
623
|
+
},
|
|
624
|
+
addons_config={
|
|
625
|
+
"gkeBackupAgentConfig": {
|
|
626
|
+
"enabled": True,
|
|
627
|
+
},
|
|
628
|
+
},
|
|
629
|
+
deletion_protection="",
|
|
630
|
+
network="default",
|
|
631
|
+
subnetwork="default")
|
|
632
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
633
|
+
name="restore-order",
|
|
634
|
+
cluster=primary.id,
|
|
635
|
+
location="us-central1",
|
|
636
|
+
backup_config={
|
|
637
|
+
"includeVolumeData": True,
|
|
638
|
+
"includeSecrets": True,
|
|
639
|
+
"allNamespaces": True,
|
|
640
|
+
})
|
|
641
|
+
restore_order = gcp.gkebackup.RestorePlan("restore_order",
|
|
642
|
+
name="restore-order",
|
|
643
|
+
location="us-central1",
|
|
644
|
+
backup_plan=basic.id,
|
|
645
|
+
cluster=primary.id,
|
|
646
|
+
restore_config={
|
|
647
|
+
"allNamespaces": True,
|
|
648
|
+
"namespacedResourceRestoreMode": "FAIL_ON_CONFLICT",
|
|
649
|
+
"volumeDataRestorePolicy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
650
|
+
"clusterResourceRestoreScope": {
|
|
651
|
+
"allGroupKinds": True,
|
|
652
|
+
},
|
|
653
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
654
|
+
"restoreOrder": {
|
|
655
|
+
"groupKindDependencies": [
|
|
656
|
+
{
|
|
657
|
+
"satisfying": {
|
|
658
|
+
"resourceGroup": "stable.example.com",
|
|
659
|
+
"resourceKind": "kindA",
|
|
660
|
+
},
|
|
661
|
+
"requiring": {
|
|
662
|
+
"resourceGroup": "stable.example.com",
|
|
663
|
+
"resourceKind": "kindB",
|
|
664
|
+
},
|
|
665
|
+
},
|
|
666
|
+
{
|
|
667
|
+
"satisfying": {
|
|
668
|
+
"resourceGroup": "stable.example.com",
|
|
669
|
+
"resourceKind": "kindB",
|
|
670
|
+
},
|
|
671
|
+
"requiring": {
|
|
672
|
+
"resourceGroup": "stable.example.com",
|
|
673
|
+
"resourceKind": "kindC",
|
|
674
|
+
},
|
|
675
|
+
},
|
|
676
|
+
],
|
|
677
|
+
},
|
|
678
|
+
})
|
|
679
|
+
```
|
|
680
|
+
### Gkebackup Restoreplan Volume Res
|
|
681
|
+
|
|
682
|
+
```python
|
|
683
|
+
import pulumi
|
|
684
|
+
import pulumi_gcp as gcp
|
|
419
685
|
|
|
420
|
-
|
|
686
|
+
primary = gcp.container.Cluster("primary",
|
|
687
|
+
name="volume-res-cluster",
|
|
688
|
+
location="us-central1",
|
|
689
|
+
initial_node_count=1,
|
|
690
|
+
workload_identity_config={
|
|
691
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
692
|
+
},
|
|
693
|
+
addons_config={
|
|
694
|
+
"gkeBackupAgentConfig": {
|
|
695
|
+
"enabled": True,
|
|
696
|
+
},
|
|
697
|
+
},
|
|
698
|
+
deletion_protection="",
|
|
699
|
+
network="default",
|
|
700
|
+
subnetwork="default")
|
|
701
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
702
|
+
name="volume-res",
|
|
703
|
+
cluster=primary.id,
|
|
704
|
+
location="us-central1",
|
|
705
|
+
backup_config={
|
|
706
|
+
"includeVolumeData": True,
|
|
707
|
+
"includeSecrets": True,
|
|
708
|
+
"allNamespaces": True,
|
|
709
|
+
})
|
|
710
|
+
volume_res = gcp.gkebackup.RestorePlan("volume_res",
|
|
711
|
+
name="volume-res",
|
|
712
|
+
location="us-central1",
|
|
713
|
+
backup_plan=basic.id,
|
|
714
|
+
cluster=primary.id,
|
|
715
|
+
restore_config={
|
|
716
|
+
"allNamespaces": True,
|
|
717
|
+
"namespacedResourceRestoreMode": "FAIL_ON_CONFLICT",
|
|
718
|
+
"volumeDataRestorePolicy": "NO_VOLUME_DATA_RESTORATION",
|
|
719
|
+
"clusterResourceRestoreScope": {
|
|
720
|
+
"allGroupKinds": True,
|
|
721
|
+
},
|
|
722
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
723
|
+
"volumeDataRestorePolicyBindings": [{
|
|
724
|
+
"policy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
725
|
+
"volumeType": "GCE_PERSISTENT_DISK",
|
|
726
|
+
}],
|
|
727
|
+
})
|
|
728
|
+
```
|
|
421
729
|
|
|
422
|
-
|
|
730
|
+
## Import
|
|
423
731
|
|
|
424
|
-
|
|
732
|
+
RestorePlan can be imported using any of these accepted formats:
|
|
425
733
|
|
|
426
|
-
* {{name}}
|
|
734
|
+
* `projects/{{project}}/locations/{{location}}/restorePlans/{{name}}`
|
|
427
735
|
|
|
428
|
-
|
|
736
|
+
* `{{project}}/{{location}}/{{name}}`
|
|
429
737
|
|
|
430
|
-
|
|
738
|
+
* `{{location}}/{{name}}`
|
|
431
739
|
|
|
432
|
-
|
|
740
|
+
When using the `pulumi import` command, RestorePlan can be imported using one of the formats above. For example:
|
|
433
741
|
|
|
434
742
|
```sh
|
|
435
|
-
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember
|
|
743
|
+
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember default projects/{{project}}/locations/{{location}}/restorePlans/{{name}}
|
|
436
744
|
```
|
|
437
745
|
|
|
438
|
-
IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.
|
|
439
|
-
|
|
440
746
|
```sh
|
|
441
|
-
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember
|
|
747
|
+
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember default {{project}}/{{location}}/{{name}}
|
|
442
748
|
```
|
|
443
749
|
|
|
444
|
-
IAM policy imports use the identifier of the resource in question, e.g.
|
|
445
|
-
|
|
446
750
|
```sh
|
|
447
|
-
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember
|
|
751
|
+
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember default {{location}}/{{name}}
|
|
448
752
|
```
|
|
449
753
|
|
|
450
|
-
-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the
|
|
451
|
-
|
|
452
|
-
full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.
|
|
453
|
-
|
|
454
754
|
:param str resource_name: The name of the resource.
|
|
455
755
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
456
756
|
:param pulumi.Input[str] location: The region of the Restore Plan.
|
|
457
|
-
|
|
458
|
-
the value will be parsed from the identifier of the parent resource. If no location is provided in the parent identifier and no
|
|
459
|
-
location is specified, it is taken from the provider configuration.
|
|
460
|
-
:param pulumi.Input[str] member: Identities that will be granted the privilege in `role`.
|
|
461
|
-
Each entry can have one of the following values:
|
|
462
|
-
* **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
|
|
463
|
-
* **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
|
|
464
|
-
* **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
|
|
465
|
-
* **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
|
|
466
|
-
* **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
|
|
467
|
-
* **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
|
|
468
|
-
* **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
|
|
469
|
-
* **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
|
|
470
|
-
* **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
|
|
471
|
-
:param pulumi.Input[str] name: Used to find the parent resource to bind the IAM policy to
|
|
472
|
-
:param pulumi.Input[str] project: The ID of the project in which the resource belongs.
|
|
473
|
-
If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
|
|
474
|
-
:param pulumi.Input[str] role: The role that should be applied. Only one
|
|
475
|
-
`gkebackup.RestorePlanIamBinding` can be used per role. Note that custom roles must be of the format
|
|
476
|
-
`[projects|organizations]/{parent-name}/roles/{role-name}`.
|
|
757
|
+
:param pulumi.Input[str] name: The full name of the BackupPlan Resource.
|
|
477
758
|
"""
|
|
478
759
|
...
|
|
479
760
|
@overload
|
|
@@ -482,148 +763,540 @@ class RestorePlanIamMember(pulumi.CustomResource):
|
|
|
482
763
|
args: RestorePlanIamMemberArgs,
|
|
483
764
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
484
765
|
"""
|
|
485
|
-
|
|
766
|
+
Represents a Restore Plan instance.
|
|
486
767
|
|
|
487
|
-
|
|
488
|
-
* `gkebackup.RestorePlanIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the restoreplan are preserved.
|
|
489
|
-
* `gkebackup.RestorePlanIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the restoreplan are preserved.
|
|
768
|
+
To get more information about RestorePlan, see:
|
|
490
769
|
|
|
491
|
-
|
|
770
|
+
* [API documentation](https://cloud.google.com/kubernetes-engine/docs/add-on/backup-for-gke/reference/rest/v1/projects.locations.restorePlans)
|
|
771
|
+
* How-to Guides
|
|
772
|
+
* [Official Documentation](https://cloud.google.com/kubernetes-engine/docs/add-on/backup-for-gke)
|
|
492
773
|
|
|
493
|
-
|
|
774
|
+
## Example Usage
|
|
494
775
|
|
|
495
|
-
|
|
776
|
+
### Gkebackup Restoreplan All Namespaces
|
|
496
777
|
|
|
497
|
-
|
|
778
|
+
```python
|
|
779
|
+
import pulumi
|
|
780
|
+
import pulumi_gcp as gcp
|
|
498
781
|
|
|
499
|
-
|
|
782
|
+
primary = gcp.container.Cluster("primary",
|
|
783
|
+
name="restore-all-ns-cluster",
|
|
784
|
+
location="us-central1",
|
|
785
|
+
initial_node_count=1,
|
|
786
|
+
workload_identity_config={
|
|
787
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
788
|
+
},
|
|
789
|
+
addons_config={
|
|
790
|
+
"gkeBackupAgentConfig": {
|
|
791
|
+
"enabled": True,
|
|
792
|
+
},
|
|
793
|
+
},
|
|
794
|
+
deletion_protection="",
|
|
795
|
+
network="default",
|
|
796
|
+
subnetwork="default")
|
|
797
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
798
|
+
name="restore-all-ns",
|
|
799
|
+
cluster=primary.id,
|
|
800
|
+
location="us-central1",
|
|
801
|
+
backup_config={
|
|
802
|
+
"includeVolumeData": True,
|
|
803
|
+
"includeSecrets": True,
|
|
804
|
+
"allNamespaces": True,
|
|
805
|
+
})
|
|
806
|
+
all_ns = gcp.gkebackup.RestorePlan("all_ns",
|
|
807
|
+
name="restore-all-ns",
|
|
808
|
+
location="us-central1",
|
|
809
|
+
backup_plan=basic.id,
|
|
810
|
+
cluster=primary.id,
|
|
811
|
+
restore_config={
|
|
812
|
+
"allNamespaces": True,
|
|
813
|
+
"namespacedResourceRestoreMode": "FAIL_ON_CONFLICT",
|
|
814
|
+
"volumeDataRestorePolicy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
815
|
+
"clusterResourceRestoreScope": {
|
|
816
|
+
"allGroupKinds": True,
|
|
817
|
+
},
|
|
818
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
819
|
+
})
|
|
820
|
+
```
|
|
821
|
+
### Gkebackup Restoreplan Rollback Namespace
|
|
500
822
|
|
|
501
823
|
```python
|
|
502
824
|
import pulumi
|
|
503
825
|
import pulumi_gcp as gcp
|
|
504
826
|
|
|
505
|
-
|
|
506
|
-
"
|
|
507
|
-
"
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
827
|
+
primary = gcp.container.Cluster("primary",
|
|
828
|
+
name="rollback-ns-cluster",
|
|
829
|
+
location="us-central1",
|
|
830
|
+
initial_node_count=1,
|
|
831
|
+
workload_identity_config={
|
|
832
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
833
|
+
},
|
|
834
|
+
addons_config={
|
|
835
|
+
"gkeBackupAgentConfig": {
|
|
836
|
+
"enabled": True,
|
|
837
|
+
},
|
|
838
|
+
},
|
|
839
|
+
deletion_protection="",
|
|
840
|
+
network="default",
|
|
841
|
+
subnetwork="default")
|
|
842
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
843
|
+
name="rollback-ns",
|
|
844
|
+
cluster=primary.id,
|
|
845
|
+
location="us-central1",
|
|
846
|
+
backup_config={
|
|
847
|
+
"includeVolumeData": True,
|
|
848
|
+
"includeSecrets": True,
|
|
849
|
+
"allNamespaces": True,
|
|
850
|
+
})
|
|
851
|
+
rollback_ns = gcp.gkebackup.RestorePlan("rollback_ns",
|
|
852
|
+
name="rollback-ns-rp",
|
|
853
|
+
location="us-central1",
|
|
854
|
+
backup_plan=basic.id,
|
|
855
|
+
cluster=primary.id,
|
|
856
|
+
restore_config={
|
|
857
|
+
"selectedNamespaces": {
|
|
858
|
+
"namespaces": ["my-ns"],
|
|
859
|
+
},
|
|
860
|
+
"namespacedResourceRestoreMode": "DELETE_AND_RESTORE",
|
|
861
|
+
"volumeDataRestorePolicy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
862
|
+
"clusterResourceRestoreScope": {
|
|
863
|
+
"selectedGroupKinds": [
|
|
864
|
+
{
|
|
865
|
+
"resourceGroup": "apiextension.k8s.io",
|
|
866
|
+
"resourceKind": "CustomResourceDefinition",
|
|
867
|
+
},
|
|
868
|
+
{
|
|
869
|
+
"resourceGroup": "storage.k8s.io",
|
|
870
|
+
"resourceKind": "StorageClass",
|
|
871
|
+
},
|
|
872
|
+
],
|
|
873
|
+
},
|
|
874
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
875
|
+
})
|
|
514
876
|
```
|
|
515
|
-
|
|
516
|
-
## gkebackup.RestorePlanIamBinding
|
|
877
|
+
### Gkebackup Restoreplan Protected Application
|
|
517
878
|
|
|
518
879
|
```python
|
|
519
880
|
import pulumi
|
|
520
881
|
import pulumi_gcp as gcp
|
|
521
882
|
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
location=
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
883
|
+
primary = gcp.container.Cluster("primary",
|
|
884
|
+
name="rollback-app-cluster",
|
|
885
|
+
location="us-central1",
|
|
886
|
+
initial_node_count=1,
|
|
887
|
+
workload_identity_config={
|
|
888
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
889
|
+
},
|
|
890
|
+
addons_config={
|
|
891
|
+
"gkeBackupAgentConfig": {
|
|
892
|
+
"enabled": True,
|
|
893
|
+
},
|
|
894
|
+
},
|
|
895
|
+
deletion_protection="",
|
|
896
|
+
network="default",
|
|
897
|
+
subnetwork="default")
|
|
898
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
899
|
+
name="rollback-app",
|
|
900
|
+
cluster=primary.id,
|
|
901
|
+
location="us-central1",
|
|
902
|
+
backup_config={
|
|
903
|
+
"includeVolumeData": True,
|
|
904
|
+
"includeSecrets": True,
|
|
905
|
+
"allNamespaces": True,
|
|
906
|
+
})
|
|
907
|
+
rollback_app = gcp.gkebackup.RestorePlan("rollback_app",
|
|
908
|
+
name="rollback-app-rp",
|
|
909
|
+
location="us-central1",
|
|
910
|
+
backup_plan=basic.id,
|
|
911
|
+
cluster=primary.id,
|
|
912
|
+
restore_config={
|
|
913
|
+
"selectedApplications": {
|
|
914
|
+
"namespacedNames": [{
|
|
915
|
+
"name": "my-app",
|
|
916
|
+
"namespace": "my-ns",
|
|
917
|
+
}],
|
|
918
|
+
},
|
|
919
|
+
"namespacedResourceRestoreMode": "DELETE_AND_RESTORE",
|
|
920
|
+
"volumeDataRestorePolicy": "REUSE_VOLUME_HANDLE_FROM_BACKUP",
|
|
921
|
+
"clusterResourceRestoreScope": {
|
|
922
|
+
"noGroupKinds": True,
|
|
923
|
+
},
|
|
924
|
+
})
|
|
528
925
|
```
|
|
529
|
-
|
|
530
|
-
## gkebackup.RestorePlanIamMember
|
|
926
|
+
### Gkebackup Restoreplan All Cluster Resources
|
|
531
927
|
|
|
532
928
|
```python
|
|
533
929
|
import pulumi
|
|
534
930
|
import pulumi_gcp as gcp
|
|
535
931
|
|
|
536
|
-
|
|
537
|
-
|
|
538
|
-
location=
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
932
|
+
primary = gcp.container.Cluster("primary",
|
|
933
|
+
name="all-groupkinds-cluster",
|
|
934
|
+
location="us-central1",
|
|
935
|
+
initial_node_count=1,
|
|
936
|
+
workload_identity_config={
|
|
937
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
938
|
+
},
|
|
939
|
+
addons_config={
|
|
940
|
+
"gkeBackupAgentConfig": {
|
|
941
|
+
"enabled": True,
|
|
942
|
+
},
|
|
943
|
+
},
|
|
944
|
+
deletion_protection="",
|
|
945
|
+
network="default",
|
|
946
|
+
subnetwork="default")
|
|
947
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
948
|
+
name="all-groupkinds",
|
|
949
|
+
cluster=primary.id,
|
|
950
|
+
location="us-central1",
|
|
951
|
+
backup_config={
|
|
952
|
+
"includeVolumeData": True,
|
|
953
|
+
"includeSecrets": True,
|
|
954
|
+
"allNamespaces": True,
|
|
955
|
+
})
|
|
956
|
+
all_cluster_resources = gcp.gkebackup.RestorePlan("all_cluster_resources",
|
|
957
|
+
name="all-groupkinds-rp",
|
|
958
|
+
location="us-central1",
|
|
959
|
+
backup_plan=basic.id,
|
|
960
|
+
cluster=primary.id,
|
|
961
|
+
restore_config={
|
|
962
|
+
"noNamespaces": True,
|
|
963
|
+
"namespacedResourceRestoreMode": "FAIL_ON_CONFLICT",
|
|
964
|
+
"clusterResourceRestoreScope": {
|
|
965
|
+
"allGroupKinds": True,
|
|
966
|
+
},
|
|
967
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
968
|
+
})
|
|
542
969
|
```
|
|
543
|
-
|
|
544
|
-
## gkebackup.RestorePlanIamPolicy
|
|
970
|
+
### Gkebackup Restoreplan Rename Namespace
|
|
545
971
|
|
|
546
972
|
```python
|
|
547
973
|
import pulumi
|
|
548
974
|
import pulumi_gcp as gcp
|
|
549
975
|
|
|
550
|
-
|
|
551
|
-
"
|
|
552
|
-
"
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
976
|
+
primary = gcp.container.Cluster("primary",
|
|
977
|
+
name="rename-ns-cluster",
|
|
978
|
+
location="us-central1",
|
|
979
|
+
initial_node_count=1,
|
|
980
|
+
workload_identity_config={
|
|
981
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
982
|
+
},
|
|
983
|
+
addons_config={
|
|
984
|
+
"gkeBackupAgentConfig": {
|
|
985
|
+
"enabled": True,
|
|
986
|
+
},
|
|
987
|
+
},
|
|
988
|
+
deletion_protection="",
|
|
989
|
+
network="default",
|
|
990
|
+
subnetwork="default")
|
|
991
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
992
|
+
name="rename-ns",
|
|
993
|
+
cluster=primary.id,
|
|
994
|
+
location="us-central1",
|
|
995
|
+
backup_config={
|
|
996
|
+
"includeVolumeData": True,
|
|
997
|
+
"includeSecrets": True,
|
|
998
|
+
"allNamespaces": True,
|
|
999
|
+
})
|
|
1000
|
+
rename_ns = gcp.gkebackup.RestorePlan("rename_ns",
|
|
1001
|
+
name="rename-ns-rp",
|
|
1002
|
+
location="us-central1",
|
|
1003
|
+
backup_plan=basic.id,
|
|
1004
|
+
cluster=primary.id,
|
|
1005
|
+
restore_config={
|
|
1006
|
+
"selectedNamespaces": {
|
|
1007
|
+
"namespaces": ["ns1"],
|
|
1008
|
+
},
|
|
1009
|
+
"namespacedResourceRestoreMode": "FAIL_ON_CONFLICT",
|
|
1010
|
+
"volumeDataRestorePolicy": "REUSE_VOLUME_HANDLE_FROM_BACKUP",
|
|
1011
|
+
"clusterResourceRestoreScope": {
|
|
1012
|
+
"noGroupKinds": True,
|
|
1013
|
+
},
|
|
1014
|
+
"transformationRules": [
|
|
1015
|
+
{
|
|
1016
|
+
"description": "rename namespace from ns1 to ns2",
|
|
1017
|
+
"resourceFilter": {
|
|
1018
|
+
"groupKinds": [{
|
|
1019
|
+
"resourceKind": "Namespace",
|
|
1020
|
+
}],
|
|
1021
|
+
"jsonPath": ".metadata[?(@.name == 'ns1')]",
|
|
1022
|
+
},
|
|
1023
|
+
"fieldActions": [{
|
|
1024
|
+
"op": "REPLACE",
|
|
1025
|
+
"path": "/metadata/name",
|
|
1026
|
+
"value": "ns2",
|
|
1027
|
+
}],
|
|
1028
|
+
},
|
|
1029
|
+
{
|
|
1030
|
+
"description": "move all resources from ns1 to ns2",
|
|
1031
|
+
"resourceFilter": {
|
|
1032
|
+
"namespaces": ["ns1"],
|
|
1033
|
+
},
|
|
1034
|
+
"fieldActions": [{
|
|
1035
|
+
"op": "REPLACE",
|
|
1036
|
+
"path": "/metadata/namespace",
|
|
1037
|
+
"value": "ns2",
|
|
1038
|
+
}],
|
|
1039
|
+
},
|
|
1040
|
+
],
|
|
1041
|
+
})
|
|
559
1042
|
```
|
|
560
|
-
|
|
561
|
-
## gkebackup.RestorePlanIamBinding
|
|
1043
|
+
### Gkebackup Restoreplan Second Transformation
|
|
562
1044
|
|
|
563
1045
|
```python
|
|
564
1046
|
import pulumi
|
|
565
1047
|
import pulumi_gcp as gcp
|
|
566
1048
|
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
location=
|
|
570
|
-
|
|
571
|
-
|
|
572
|
-
|
|
1049
|
+
primary = gcp.container.Cluster("primary",
|
|
1050
|
+
name="transform-rule-cluster",
|
|
1051
|
+
location="us-central1",
|
|
1052
|
+
initial_node_count=1,
|
|
1053
|
+
workload_identity_config={
|
|
1054
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
1055
|
+
},
|
|
1056
|
+
addons_config={
|
|
1057
|
+
"gkeBackupAgentConfig": {
|
|
1058
|
+
"enabled": True,
|
|
1059
|
+
},
|
|
1060
|
+
},
|
|
1061
|
+
deletion_protection="",
|
|
1062
|
+
network="default",
|
|
1063
|
+
subnetwork="default")
|
|
1064
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
1065
|
+
name="transform-rule",
|
|
1066
|
+
cluster=primary.id,
|
|
1067
|
+
location="us-central1",
|
|
1068
|
+
backup_config={
|
|
1069
|
+
"includeVolumeData": True,
|
|
1070
|
+
"includeSecrets": True,
|
|
1071
|
+
"allNamespaces": True,
|
|
1072
|
+
})
|
|
1073
|
+
transform_rule = gcp.gkebackup.RestorePlan("transform_rule",
|
|
1074
|
+
name="transform-rule-rp",
|
|
1075
|
+
description="copy nginx env variables",
|
|
1076
|
+
labels={
|
|
1077
|
+
"app": "nginx",
|
|
1078
|
+
},
|
|
1079
|
+
location="us-central1",
|
|
1080
|
+
backup_plan=basic.id,
|
|
1081
|
+
cluster=primary.id,
|
|
1082
|
+
restore_config={
|
|
1083
|
+
"excludedNamespaces": {
|
|
1084
|
+
"namespaces": ["my-ns"],
|
|
1085
|
+
},
|
|
1086
|
+
"namespacedResourceRestoreMode": "DELETE_AND_RESTORE",
|
|
1087
|
+
"volumeDataRestorePolicy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
1088
|
+
"clusterResourceRestoreScope": {
|
|
1089
|
+
"excludedGroupKinds": [{
|
|
1090
|
+
"resourceGroup": "apiextension.k8s.io",
|
|
1091
|
+
"resourceKind": "CustomResourceDefinition",
|
|
1092
|
+
}],
|
|
1093
|
+
},
|
|
1094
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
1095
|
+
"transformationRules": [{
|
|
1096
|
+
"description": "Copy environment variables from the nginx container to the install init container.",
|
|
1097
|
+
"resourceFilter": {
|
|
1098
|
+
"groupKinds": [{
|
|
1099
|
+
"resourceKind": "Pod",
|
|
1100
|
+
"resourceGroup": "",
|
|
1101
|
+
}],
|
|
1102
|
+
"jsonPath": ".metadata[?(@.name == 'nginx')]",
|
|
1103
|
+
},
|
|
1104
|
+
"fieldActions": [{
|
|
1105
|
+
"op": "COPY",
|
|
1106
|
+
"path": "/spec/initContainers/0/env",
|
|
1107
|
+
"fromPath": "/spec/containers/0/env",
|
|
1108
|
+
}],
|
|
1109
|
+
}],
|
|
1110
|
+
})
|
|
573
1111
|
```
|
|
574
|
-
|
|
575
|
-
## gkebackup.RestorePlanIamMember
|
|
1112
|
+
### Gkebackup Restoreplan Gitops Mode
|
|
576
1113
|
|
|
577
1114
|
```python
|
|
578
1115
|
import pulumi
|
|
579
1116
|
import pulumi_gcp as gcp
|
|
580
1117
|
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
location=
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
1118
|
+
primary = gcp.container.Cluster("primary",
|
|
1119
|
+
name="gitops-mode-cluster",
|
|
1120
|
+
location="us-central1",
|
|
1121
|
+
initial_node_count=1,
|
|
1122
|
+
workload_identity_config={
|
|
1123
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
1124
|
+
},
|
|
1125
|
+
addons_config={
|
|
1126
|
+
"gkeBackupAgentConfig": {
|
|
1127
|
+
"enabled": True,
|
|
1128
|
+
},
|
|
1129
|
+
},
|
|
1130
|
+
deletion_protection="",
|
|
1131
|
+
network="default",
|
|
1132
|
+
subnetwork="default")
|
|
1133
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
1134
|
+
name="gitops-mode",
|
|
1135
|
+
cluster=primary.id,
|
|
1136
|
+
location="us-central1",
|
|
1137
|
+
backup_config={
|
|
1138
|
+
"includeVolumeData": True,
|
|
1139
|
+
"includeSecrets": True,
|
|
1140
|
+
"allNamespaces": True,
|
|
1141
|
+
})
|
|
1142
|
+
gitops_mode = gcp.gkebackup.RestorePlan("gitops_mode",
|
|
1143
|
+
name="gitops-mode",
|
|
1144
|
+
location="us-central1",
|
|
1145
|
+
backup_plan=basic.id,
|
|
1146
|
+
cluster=primary.id,
|
|
1147
|
+
restore_config={
|
|
1148
|
+
"allNamespaces": True,
|
|
1149
|
+
"namespacedResourceRestoreMode": "MERGE_SKIP_ON_CONFLICT",
|
|
1150
|
+
"volumeDataRestorePolicy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
1151
|
+
"clusterResourceRestoreScope": {
|
|
1152
|
+
"allGroupKinds": True,
|
|
1153
|
+
},
|
|
1154
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
1155
|
+
})
|
|
587
1156
|
```
|
|
1157
|
+
### Gkebackup Restoreplan Restore Order
|
|
588
1158
|
|
|
589
|
-
|
|
1159
|
+
```python
|
|
1160
|
+
import pulumi
|
|
1161
|
+
import pulumi_gcp as gcp
|
|
590
1162
|
|
|
591
|
-
|
|
1163
|
+
primary = gcp.container.Cluster("primary",
|
|
1164
|
+
name="restore-order-cluster",
|
|
1165
|
+
location="us-central1",
|
|
1166
|
+
initial_node_count=1,
|
|
1167
|
+
workload_identity_config={
|
|
1168
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
1169
|
+
},
|
|
1170
|
+
addons_config={
|
|
1171
|
+
"gkeBackupAgentConfig": {
|
|
1172
|
+
"enabled": True,
|
|
1173
|
+
},
|
|
1174
|
+
},
|
|
1175
|
+
deletion_protection="",
|
|
1176
|
+
network="default",
|
|
1177
|
+
subnetwork="default")
|
|
1178
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
1179
|
+
name="restore-order",
|
|
1180
|
+
cluster=primary.id,
|
|
1181
|
+
location="us-central1",
|
|
1182
|
+
backup_config={
|
|
1183
|
+
"includeVolumeData": True,
|
|
1184
|
+
"includeSecrets": True,
|
|
1185
|
+
"allNamespaces": True,
|
|
1186
|
+
})
|
|
1187
|
+
restore_order = gcp.gkebackup.RestorePlan("restore_order",
|
|
1188
|
+
name="restore-order",
|
|
1189
|
+
location="us-central1",
|
|
1190
|
+
backup_plan=basic.id,
|
|
1191
|
+
cluster=primary.id,
|
|
1192
|
+
restore_config={
|
|
1193
|
+
"allNamespaces": True,
|
|
1194
|
+
"namespacedResourceRestoreMode": "FAIL_ON_CONFLICT",
|
|
1195
|
+
"volumeDataRestorePolicy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
1196
|
+
"clusterResourceRestoreScope": {
|
|
1197
|
+
"allGroupKinds": True,
|
|
1198
|
+
},
|
|
1199
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
1200
|
+
"restoreOrder": {
|
|
1201
|
+
"groupKindDependencies": [
|
|
1202
|
+
{
|
|
1203
|
+
"satisfying": {
|
|
1204
|
+
"resourceGroup": "stable.example.com",
|
|
1205
|
+
"resourceKind": "kindA",
|
|
1206
|
+
},
|
|
1207
|
+
"requiring": {
|
|
1208
|
+
"resourceGroup": "stable.example.com",
|
|
1209
|
+
"resourceKind": "kindB",
|
|
1210
|
+
},
|
|
1211
|
+
},
|
|
1212
|
+
{
|
|
1213
|
+
"satisfying": {
|
|
1214
|
+
"resourceGroup": "stable.example.com",
|
|
1215
|
+
"resourceKind": "kindB",
|
|
1216
|
+
},
|
|
1217
|
+
"requiring": {
|
|
1218
|
+
"resourceGroup": "stable.example.com",
|
|
1219
|
+
"resourceKind": "kindC",
|
|
1220
|
+
},
|
|
1221
|
+
},
|
|
1222
|
+
],
|
|
1223
|
+
},
|
|
1224
|
+
})
|
|
1225
|
+
```
|
|
1226
|
+
### Gkebackup Restoreplan Volume Res
|
|
592
1227
|
|
|
593
|
-
|
|
1228
|
+
```python
|
|
1229
|
+
import pulumi
|
|
1230
|
+
import pulumi_gcp as gcp
|
|
594
1231
|
|
|
595
|
-
|
|
1232
|
+
primary = gcp.container.Cluster("primary",
|
|
1233
|
+
name="volume-res-cluster",
|
|
1234
|
+
location="us-central1",
|
|
1235
|
+
initial_node_count=1,
|
|
1236
|
+
workload_identity_config={
|
|
1237
|
+
"workloadPool": "my-project-name.svc.id.goog",
|
|
1238
|
+
},
|
|
1239
|
+
addons_config={
|
|
1240
|
+
"gkeBackupAgentConfig": {
|
|
1241
|
+
"enabled": True,
|
|
1242
|
+
},
|
|
1243
|
+
},
|
|
1244
|
+
deletion_protection="",
|
|
1245
|
+
network="default",
|
|
1246
|
+
subnetwork="default")
|
|
1247
|
+
basic = gcp.gkebackup.BackupPlan("basic",
|
|
1248
|
+
name="volume-res",
|
|
1249
|
+
cluster=primary.id,
|
|
1250
|
+
location="us-central1",
|
|
1251
|
+
backup_config={
|
|
1252
|
+
"includeVolumeData": True,
|
|
1253
|
+
"includeSecrets": True,
|
|
1254
|
+
"allNamespaces": True,
|
|
1255
|
+
})
|
|
1256
|
+
volume_res = gcp.gkebackup.RestorePlan("volume_res",
|
|
1257
|
+
name="volume-res",
|
|
1258
|
+
location="us-central1",
|
|
1259
|
+
backup_plan=basic.id,
|
|
1260
|
+
cluster=primary.id,
|
|
1261
|
+
restore_config={
|
|
1262
|
+
"allNamespaces": True,
|
|
1263
|
+
"namespacedResourceRestoreMode": "FAIL_ON_CONFLICT",
|
|
1264
|
+
"volumeDataRestorePolicy": "NO_VOLUME_DATA_RESTORATION",
|
|
1265
|
+
"clusterResourceRestoreScope": {
|
|
1266
|
+
"allGroupKinds": True,
|
|
1267
|
+
},
|
|
1268
|
+
"clusterResourceConflictPolicy": "USE_EXISTING_VERSION",
|
|
1269
|
+
"volumeDataRestorePolicyBindings": [{
|
|
1270
|
+
"policy": "RESTORE_VOLUME_DATA_FROM_BACKUP",
|
|
1271
|
+
"volumeType": "GCE_PERSISTENT_DISK",
|
|
1272
|
+
}],
|
|
1273
|
+
})
|
|
1274
|
+
```
|
|
1275
|
+
|
|
1276
|
+
## Import
|
|
596
1277
|
|
|
597
|
-
|
|
1278
|
+
RestorePlan can be imported using any of these accepted formats:
|
|
598
1279
|
|
|
599
|
-
* {{name}}
|
|
1280
|
+
* `projects/{{project}}/locations/{{location}}/restorePlans/{{name}}`
|
|
600
1281
|
|
|
601
|
-
|
|
1282
|
+
* `{{project}}/{{location}}/{{name}}`
|
|
602
1283
|
|
|
603
|
-
|
|
1284
|
+
* `{{location}}/{{name}}`
|
|
604
1285
|
|
|
605
|
-
|
|
1286
|
+
When using the `pulumi import` command, RestorePlan can be imported using one of the formats above. For example:
|
|
606
1287
|
|
|
607
1288
|
```sh
|
|
608
|
-
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember
|
|
1289
|
+
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember default projects/{{project}}/locations/{{location}}/restorePlans/{{name}}
|
|
609
1290
|
```
|
|
610
1291
|
|
|
611
|
-
IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.
|
|
612
|
-
|
|
613
1292
|
```sh
|
|
614
|
-
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember
|
|
1293
|
+
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember default {{project}}/{{location}}/{{name}}
|
|
615
1294
|
```
|
|
616
1295
|
|
|
617
|
-
IAM policy imports use the identifier of the resource in question, e.g.
|
|
618
|
-
|
|
619
1296
|
```sh
|
|
620
|
-
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember
|
|
1297
|
+
$ pulumi import gcp:gkebackup/restorePlanIamMember:RestorePlanIamMember default {{location}}/{{name}}
|
|
621
1298
|
```
|
|
622
1299
|
|
|
623
|
-
-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the
|
|
624
|
-
|
|
625
|
-
full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.
|
|
626
|
-
|
|
627
1300
|
:param str resource_name: The name of the resource.
|
|
628
1301
|
:param RestorePlanIamMemberArgs args: The arguments to use to populate this resource's properties.
|
|
629
1302
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
@@ -689,28 +1362,8 @@ class RestorePlanIamMember(pulumi.CustomResource):
|
|
|
689
1362
|
:param str resource_name: The unique name of the resulting resource.
|
|
690
1363
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
691
1364
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
692
|
-
:param pulumi.Input[str] etag: (Computed) The etag of the IAM policy.
|
|
693
1365
|
:param pulumi.Input[str] location: The region of the Restore Plan.
|
|
694
|
-
|
|
695
|
-
the value will be parsed from the identifier of the parent resource. If no location is provided in the parent identifier and no
|
|
696
|
-
location is specified, it is taken from the provider configuration.
|
|
697
|
-
:param pulumi.Input[str] member: Identities that will be granted the privilege in `role`.
|
|
698
|
-
Each entry can have one of the following values:
|
|
699
|
-
* **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
|
|
700
|
-
* **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
|
|
701
|
-
* **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
|
|
702
|
-
* **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
|
|
703
|
-
* **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
|
|
704
|
-
* **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
|
|
705
|
-
* **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
|
|
706
|
-
* **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
|
|
707
|
-
* **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
|
|
708
|
-
:param pulumi.Input[str] name: Used to find the parent resource to bind the IAM policy to
|
|
709
|
-
:param pulumi.Input[str] project: The ID of the project in which the resource belongs.
|
|
710
|
-
If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
|
|
711
|
-
:param pulumi.Input[str] role: The role that should be applied. Only one
|
|
712
|
-
`gkebackup.RestorePlanIamBinding` can be used per role. Note that custom roles must be of the format
|
|
713
|
-
`[projects|organizations]/{parent-name}/roles/{role-name}`.
|
|
1366
|
+
:param pulumi.Input[str] name: The full name of the BackupPlan Resource.
|
|
714
1367
|
"""
|
|
715
1368
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
716
1369
|
|
|
@@ -733,9 +1386,6 @@ class RestorePlanIamMember(pulumi.CustomResource):
|
|
|
733
1386
|
@property
|
|
734
1387
|
@pulumi.getter
|
|
735
1388
|
def etag(self) -> pulumi.Output[str]:
|
|
736
|
-
"""
|
|
737
|
-
(Computed) The etag of the IAM policy.
|
|
738
|
-
"""
|
|
739
1389
|
return pulumi.get(self, "etag")
|
|
740
1390
|
|
|
741
1391
|
@property
|
|
@@ -743,54 +1393,29 @@ class RestorePlanIamMember(pulumi.CustomResource):
|
|
|
743
1393
|
def location(self) -> pulumi.Output[str]:
|
|
744
1394
|
"""
|
|
745
1395
|
The region of the Restore Plan.
|
|
746
|
-
Used to find the parent resource to bind the IAM policy to. If not specified,
|
|
747
|
-
the value will be parsed from the identifier of the parent resource. If no location is provided in the parent identifier and no
|
|
748
|
-
location is specified, it is taken from the provider configuration.
|
|
749
1396
|
"""
|
|
750
1397
|
return pulumi.get(self, "location")
|
|
751
1398
|
|
|
752
1399
|
@property
|
|
753
1400
|
@pulumi.getter
|
|
754
1401
|
def member(self) -> pulumi.Output[str]:
|
|
755
|
-
"""
|
|
756
|
-
Identities that will be granted the privilege in `role`.
|
|
757
|
-
Each entry can have one of the following values:
|
|
758
|
-
* **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
|
|
759
|
-
* **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
|
|
760
|
-
* **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
|
|
761
|
-
* **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
|
|
762
|
-
* **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
|
|
763
|
-
* **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
|
|
764
|
-
* **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
|
|
765
|
-
* **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
|
|
766
|
-
* **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
|
|
767
|
-
"""
|
|
768
1402
|
return pulumi.get(self, "member")
|
|
769
1403
|
|
|
770
1404
|
@property
|
|
771
1405
|
@pulumi.getter
|
|
772
1406
|
def name(self) -> pulumi.Output[str]:
|
|
773
1407
|
"""
|
|
774
|
-
|
|
1408
|
+
The full name of the BackupPlan Resource.
|
|
775
1409
|
"""
|
|
776
1410
|
return pulumi.get(self, "name")
|
|
777
1411
|
|
|
778
1412
|
@property
|
|
779
1413
|
@pulumi.getter
|
|
780
1414
|
def project(self) -> pulumi.Output[str]:
|
|
781
|
-
"""
|
|
782
|
-
The ID of the project in which the resource belongs.
|
|
783
|
-
If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
|
|
784
|
-
"""
|
|
785
1415
|
return pulumi.get(self, "project")
|
|
786
1416
|
|
|
787
1417
|
@property
|
|
788
1418
|
@pulumi.getter
|
|
789
1419
|
def role(self) -> pulumi.Output[str]:
|
|
790
|
-
"""
|
|
791
|
-
The role that should be applied. Only one
|
|
792
|
-
`gkebackup.RestorePlanIamBinding` can be used per role. Note that custom roles must be of the format
|
|
793
|
-
`[projects|organizations]/{parent-name}/roles/{role-name}`.
|
|
794
|
-
"""
|
|
795
1420
|
return pulumi.get(self, "role")
|
|
796
1421
|
|