0
# Resource Group Management
1
2
Comprehensive resource group management for organizing and categorizing monitored resources in Google Cloud Monitoring. Groups enable bulk operations, simplified resource management, and hierarchical organization of your monitoring infrastructure.
3
4
## Capabilities
5
6
### Group Operations
7
8
Manage the complete lifecycle of resource groups including creation, updates, retrieval, deletion, and member management.
9
10
```python { .api }
11
class GroupServiceClient:
12
def list_groups(
13
self,
14
request=None,
15
*,
16
name: str = None,
17
retry=None,
18
timeout=None,
19
metadata=()
20
) -> pagers.ListGroupsPager:
21
"""
22
Lists the existing groups.
23
24
Args:
25
request: The request object or dict equivalent
26
name: Required. Project name in format 'projects/[PROJECT_ID]'
27
retry: Retry configuration
28
timeout: Request timeout in seconds
29
metadata: Additional metadata
30
31
Returns:
32
Pager for iterating over Group objects
33
"""
34
35
def get_group(
36
self,
37
request=None,
38
*,
39
name: str = None,
40
retry=None,
41
timeout=None,
42
metadata=()
43
) -> group.Group:
44
"""
45
Gets a single group.
46
47
Args:
48
request: The request object or dict equivalent
49
name: Required. Group name in format 'projects/[PROJECT_ID]/groups/[GROUP_ID]'
50
retry: Retry configuration
51
timeout: Request timeout in seconds
52
metadata: Additional metadata
53
54
Returns:
55
Group object
56
"""
57
58
def create_group(
59
self,
60
request=None,
61
*,
62
name: str = None,
63
group: group.Group = None,
64
retry=None,
65
timeout=None,
66
metadata=()
67
) -> group.Group:
68
"""
69
Creates a new group.
70
71
Args:
72
request: The request object or dict equivalent
73
name: Required. Project name
74
group: Required. The group to create
75
retry: Retry configuration
76
timeout: Request timeout in seconds
77
metadata: Additional metadata
78
79
Returns:
80
Created Group object
81
"""
82
83
def update_group(
84
self,
85
request=None,
86
*,
87
group: group.Group = None,
88
retry=None,
89
timeout=None,
90
metadata=()
91
) -> group.Group:
92
"""
93
Updates an existing group.
94
95
Args:
96
request: The request object or dict equivalent
97
group: Required. Updated group
98
retry: Retry configuration
99
timeout: Request timeout in seconds
100
metadata: Additional metadata
101
102
Returns:
103
Updated Group object
104
"""
105
106
def delete_group(
107
self,
108
request=None,
109
*,
110
name: str = None,
111
retry=None,
112
timeout=None,
113
metadata=()
114
) -> None:
115
"""
116
Deletes an existing group.
117
118
Args:
119
request: The request object or dict equivalent
120
name: Required. Group name to delete
121
retry: Retry configuration
122
timeout: Request timeout in seconds
123
metadata: Additional metadata
124
"""
125
126
def list_group_members(
127
self,
128
request=None,
129
*,
130
name: str = None,
131
retry=None,
132
timeout=None,
133
metadata=()
134
) -> pagers.ListGroupMembersPager:
135
"""
136
Lists the monitored resources that are members of a group.
137
138
Args:
139
request: The request object or dict equivalent
140
name: Required. Group name
141
retry: Retry configuration
142
timeout: Request timeout in seconds
143
metadata: Additional metadata
144
145
Returns:
146
Pager for iterating over MonitoredResource objects
147
"""
148
```
149
150
## Data Types
151
152
### Group
153
154
Represents a logical group of monitored resources.
155
156
```python { .api }
157
class Group:
158
name: str # Resource name
159
display_name: str # Human-readable name
160
parent_name: str # Parent group name
161
filter: str # Filter defining group membership
162
is_cluster: bool # Whether group represents a cluster
163
```
164
165
### Request and Response Types
166
167
```python { .api }
168
class CreateGroupRequest:
169
name: str # Required. Project name
170
group: Group # Required. Group to create
171
validate_only: bool # Only validate, don't create
172
173
class DeleteGroupRequest:
174
name: str # Required. Group name to delete
175
recursive: bool # Delete child groups recursively
176
177
class GetGroupRequest:
178
name: str # Required. Group name to retrieve
179
180
class ListGroupsRequest:
181
name: str # Required. Project name
182
children_of_group: str # Parent group filter
183
ancestors_of_group: str # Ancestor group filter
184
descendants_of_group: str # Descendant group filter
185
page_size: int # Maximum results per page
186
page_token: str # Page token for pagination
187
188
class ListGroupsResponse:
189
group: List[Group] # Groups
190
next_page_token: str # Token for next page
191
192
class ListGroupMembersRequest:
193
name: str # Required. Group name
194
page_size: int # Maximum results per page
195
page_token: str # Page token for pagination
196
filter: str # Additional resource filter
197
interval: TimeInterval # Time interval for membership
198
199
class ListGroupMembersResponse:
200
members: List[MonitoredResource] # Group members
201
next_page_token: str # Token for next page
202
total_size: int # Total member count
203
204
class UpdateGroupRequest:
205
group: Group # Required. Updated group
206
validate_only: bool # Only validate, don't update
207
```
208
209
## Usage Examples
210
211
### Creating a Resource Group
212
213
```python
214
from google.cloud.monitoring import GroupServiceClient, Group
215
216
client = GroupServiceClient()
217
project_name = f"projects/{project_id}"
218
219
# Create a group for production web servers
220
group = Group()
221
group.display_name = "Production Web Servers"
222
group.filter = 'resource.type="gce_instance" AND resource.label.env="production" AND resource.label.role="web"'
223
224
created_group = client.create_group(
225
name=project_name,
226
group=group
227
)
228
print(f"Created group: {created_group.name}")
229
print(f"Group filter: {created_group.filter}")
230
```
231
232
### Creating Hierarchical Groups
233
234
```python
235
# Create parent group
236
parent_group = Group()
237
parent_group.display_name = "Production Environment"
238
parent_group.filter = 'resource.label.env="production"'
239
240
created_parent = client.create_group(
241
name=project_name,
242
group=parent_group
243
)
244
245
# Create child group
246
child_group = Group()
247
child_group.display_name = "Production Databases"
248
child_group.parent_name = created_parent.name
249
child_group.filter = 'resource.type="gce_instance" AND resource.label.env="production" AND resource.label.role="database"'
250
251
created_child = client.create_group(
252
name=project_name,
253
group=child_group
254
)
255
print(f"Created child group: {created_child.name}")
256
print(f"Parent: {created_child.parent_name}")
257
```
258
259
### Listing Groups with Filtering
260
261
```python
262
client = GroupServiceClient()
263
project_name = f"projects/{project_id}"
264
265
# List all groups
266
print("All groups:")
267
for group in client.list_groups(name=project_name):
268
print(f"- {group.display_name}: {group.name}")
269
270
# List child groups of a specific parent
271
parent_group_name = f"projects/{project_id}/groups/{parent_group_id}"
272
print(f"\nChildren of {parent_group_name}:")
273
for group in client.list_groups(name=project_name, children_of_group=parent_group_name):
274
print(f"- {group.display_name}")
275
276
# List ancestor groups
277
print(f"\nAncestors of {child_group_name}:")
278
for group in client.list_groups(name=project_name, ancestors_of_group=child_group_name):
279
print(f"- {group.display_name}")
280
```
281
282
### Listing Group Members
283
284
```python
285
group_name = f"projects/{project_id}/groups/{group_id}"
286
287
# List all members of a group
288
print(f"Members of group {group_name}:")
289
for member in client.list_group_members(name=group_name):
290
print(f"- Type: {member.type}")
291
print(f" Labels: {dict(member.labels)}")
292
293
# List members with additional filtering
294
additional_filter = 'resource.label.zone="us-central1-a"'
295
print(f"\nMembers in zone us-central1-a:")
296
for member in client.list_group_members(name=group_name, filter=additional_filter):
297
print(f"- {member.type}: {member.labels}")
298
```
299
300
### Updating a Group
301
302
```python
303
# Get existing group
304
group_name = f"projects/{project_id}/groups/{group_id}"
305
group = client.get_group(name=group_name)
306
307
# Update the group
308
group.display_name = "Updated Production Web Servers"
309
group.filter = 'resource.type="gce_instance" AND resource.label.env="production" AND (resource.label.role="web" OR resource.label.role="api")'
310
311
updated_group = client.update_group(group=group)
312
print(f"Updated group: {updated_group.display_name}")
313
print(f"New filter: {updated_group.filter}")
314
```
315
316
### Deleting Groups
317
318
```python
319
# Delete a single group
320
group_name = f"projects/{project_id}/groups/{group_id}"
321
client.delete_group(name=group_name)
322
print(f"Deleted group: {group_name}")
323
324
# Delete group and all children recursively
325
parent_group_name = f"projects/{project_id}/groups/{parent_group_id}"
326
client.delete_group(name=parent_group_name, recursive=True)
327
print(f"Deleted group and children: {parent_group_name}")
328
```
329
330
### Validation-Only Operations
331
332
```python
333
# Validate group creation without actually creating
334
test_group = Group()
335
test_group.display_name = "Test Group"
336
test_group.filter = 'invalid_filter_expression'
337
338
try:
339
# This will validate the group but not create it
340
client.create_group(
341
name=project_name,
342
group=test_group,
343
validate_only=True
344
)
345
print("Group validation passed")
346
except Exception as e:
347
print(f"Group validation failed: {e}")
348
```
349
350
### Working with Group Membership over Time
351
352
```python
353
from google.cloud.monitoring_v3.types import TimeInterval
354
from google.protobuf.timestamp_pb2 import Timestamp
355
import time
356
357
group_name = f"projects/{project_id}/groups/{group_id}"
358
359
# Define time interval for historical membership
360
now = time.time()
361
interval = TimeInterval()
362
interval.end_time.seconds = int(now)
363
interval.start_time.seconds = int(now - 3600) # 1 hour ago
364
365
# Get group membership at specific time
366
for member in client.list_group_members(name=group_name, interval=interval):
367
print(f"Historical member: {member.type}")
368
```
369
370
### Async Group Operations
371
372
```python
373
import asyncio
374
from google.cloud.monitoring import GroupServiceAsyncClient
375
376
async def manage_groups():
377
client = GroupServiceAsyncClient()
378
project_name = f"projects/{project_id}"
379
380
# List groups asynchronously
381
async for group in await client.list_groups(name=project_name):
382
print(f"Async group: {group.display_name}")
383
384
# Create group asynchronously
385
new_group = Group()
386
new_group.display_name = "Async Created Group"
387
new_group.filter = 'resource.type="gce_instance"'
388
389
created = await client.create_group(name=project_name, group=new_group)
390
print(f"Async created group: {created.name}")
391
392
asyncio.run(manage_groups())
393
```
394
395
## Resource Path Helpers
396
397
```python { .api }
398
class GroupServiceClient:
399
@staticmethod
400
def group_path(project: str, group: str) -> str:
401
"""Returns a fully-qualified group string."""
402
403
@staticmethod
404
def parse_group_path(path: str) -> Dict[str, str]:
405
"""Parses a group path into its component segments."""
406
```
407
408
## Error Handling
409
410
Group operations can raise specific exceptions:
411
412
```python
413
from google.api_core import exceptions
414
from google.cloud.monitoring import GroupServiceClient
415
416
client = GroupServiceClient()
417
418
try:
419
group = client.get_group(name="invalid/path")
420
except exceptions.NotFound:
421
print("Group not found")
422
except exceptions.InvalidArgument as e:
423
print(f"Invalid group filter: {e}")
424
except exceptions.PermissionDenied:
425
print("Insufficient permissions")
426
except exceptions.FailedPrecondition as e:
427
print(f"Cannot delete group with children: {e}")
428
```