0
# Integration Runtime Management
1

2
Integration runtime provisioning, configuration, monitoring, and credential management for data integration scenarios. Integration runtimes provide the compute infrastructure for data movement, data flow execution, and SSIS package execution within Azure Synapse Analytics.
3

4
## Capabilities
5

6
### Integration Runtime Operations
7

8
Core integration runtime lifecycle management including creation, retrieval, updates, and deletion.
9

10
```python { .api }
11
def get(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> IntegrationRuntimeResource:
12
    """
13
    Get an integration runtime.
14
    
15
    Parameters:
16
    - resource_group_name (str): Name of the resource group
17
    - workspace_name (str): Name of the workspace
18
    - integration_runtime_name (str): Name of the integration runtime
19
    
20
    Returns:
21
    IntegrationRuntimeResource: The integration runtime object
22
    """
23

24
def create(resource_group_name: str, workspace_name: str, integration_runtime_name: str, integration_runtime: IntegrationRuntimeResource) -> LROPoller[IntegrationRuntimeResource]:
25
    """
26
    Create an integration runtime.
27
    
28
    Parameters:
29
    - resource_group_name (str): Name of the resource group
30
    - workspace_name (str): Name of the workspace
31
    - integration_runtime_name (str): Name of the integration runtime
32
    - integration_runtime (IntegrationRuntimeResource): Integration runtime properties
33
    
34
    Returns:
35
    LROPoller[IntegrationRuntimeResource]: Long-running operation poller
36
    """
37

38
def update(resource_group_name: str, workspace_name: str, integration_runtime_name: str, update_integration_runtime_request: UpdateIntegrationRuntimeRequest) -> IntegrationRuntimeResource:
39
    """
40
    Update integration runtime properties.
41
    
42
    Parameters:
43
    - resource_group_name (str): Name of the resource group
44
    - workspace_name (str): Name of the workspace
45
    - integration_runtime_name (str): Name of the integration runtime
46
    - update_integration_runtime_request (UpdateIntegrationRuntimeRequest): Update parameters
47
    
48
    Returns:
49
    IntegrationRuntimeResource: Updated integration runtime
50
    """
51

52
def delete(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> LROPoller[object]:
53
    """
54
    Delete an integration runtime.
55
    
56
    Parameters:
57
    - resource_group_name (str): Name of the resource group
58
    - workspace_name (str): Name of the workspace
59
    - integration_runtime_name (str): Name of the integration runtime
60
    
61
    Returns:
62
    LROPoller[object]: Long-running operation poller
63
    """
64

65
def list_by_workspace(resource_group_name: str, workspace_name: str) -> ItemPaged[IntegrationRuntimeResource]:
66
    """
67
    List integration runtimes in a workspace.
68
    
69
    Parameters:
70
    - resource_group_name (str): Name of the resource group
71
    - workspace_name (str): Name of the workspace
72
    
73
    Returns:
74
    ItemPaged[IntegrationRuntimeResource]: Paged collection of integration runtimes
75
    """
76
```
77

78
### Integration Runtime State Management
79

80
Operations to control integration runtime state including start, stop, and upgrade operations.
81

82
```python { .api }
83
def start(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> LROPoller[IntegrationRuntimeStatusResponse]:
84
    """
85
    Start an integration runtime.
86
    
87
    Parameters:
88
    - resource_group_name (str): Name of the resource group
89
    - workspace_name (str): Name of the workspace
90
    - integration_runtime_name (str): Name of the integration runtime
91
    
92
    Returns:
93
    LROPoller[IntegrationRuntimeStatusResponse]: Long-running operation poller
94
    """
95

96
def stop(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> LROPoller[object]:
97
    """
98
    Stop an integration runtime.
99
    
100
    Parameters:
101
    - resource_group_name (str): Name of the resource group
102
    - workspace_name (str): Name of the workspace
103
    - integration_runtime_name (str): Name of the integration runtime
104
    
105
    Returns:
106
    LROPoller[object]: Long-running operation poller
107
    """
108

109
def upgrade(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> None:
110
    """
111
    Upgrade an integration runtime.
112
    
113
    Parameters:
114
    - resource_group_name (str): Name of the resource group
115
    - workspace_name (str): Name of the workspace
116
    - integration_runtime_name (str): Name of the integration runtime
117
    """
118
```
119

120
### Integration Runtime Status and Monitoring
121

122
Monitor integration runtime status, performance, and health.
123

124
```python { .api }
125
def get_status(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> IntegrationRuntimeStatusResponse:
126
    """
127
    Get integration runtime status.
128
    
129
    Parameters:
130
    - resource_group_name (str): Name of the resource group
131
    - workspace_name (str): Name of the workspace
132
    - integration_runtime_name (str): Name of the integration runtime
133
    
134
    Returns:
135
    IntegrationRuntimeStatusResponse: Integration runtime status
136
    """
137

138
def get_monitoring_data(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> IntegrationRuntimeMonitoringData:
139
    """
140
    Get integration runtime monitoring data.
141
    
142
    Parameters:
143
    - resource_group_name (str): Name of the resource group
144
    - workspace_name (str): Name of the workspace
145
    - integration_runtime_name (str): Name of the integration runtime
146
    
147
    Returns:
148
    IntegrationRuntimeMonitoringData: Monitoring data
149
    """
150

151
def get_connection_info(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> IntegrationRuntimeConnectionInfo:
152
    """
153
    Get integration runtime connection info.
154
    
155
    Parameters:
156
    - resource_group_name (str): Name of the resource group
157
    - workspace_name (str): Name of the workspace
158
    - integration_runtime_name (str): Name of the integration runtime
159
    
160
    Returns:
161
    IntegrationRuntimeConnectionInfo: Connection information
162
    """
163
```
164

165
### Integration Runtime Authentication
166

167
Manage authentication keys and credentials for integration runtime security.
168

169
```python { .api }
170
def list_auth_keys(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> IntegrationRuntimeAuthKeys:
171
    """
172
    List integration runtime authentication keys.
173
    
174
    Parameters:
175
    - resource_group_name (str): Name of the resource group
176
    - workspace_name (str): Name of the workspace
177
    - integration_runtime_name (str): Name of the integration runtime
178
    
179
    Returns:
180
    IntegrationRuntimeAuthKeys: Authentication keys
181
    """
182

183
def regenerate_auth_key(resource_group_name: str, workspace_name: str, integration_runtime_name: str, regenerate_key_parameters: IntegrationRuntimeRegenerateKeyParameters) -> IntegrationRuntimeAuthKeys:
184
    """
185
    Regenerate integration runtime authentication key.
186
    
187
    Parameters:
188
    - resource_group_name (str): Name of the resource group
189
    - workspace_name (str): Name of the workspace
190
    - integration_runtime_name (str): Name of the integration runtime
191
    - regenerate_key_parameters (IntegrationRuntimeRegenerateKeyParameters): Key regeneration parameters
192
    
193
    Returns:
194
    IntegrationRuntimeAuthKeys: New authentication keys
195
    """
196

197
def sync_credentials(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> None:
198
    """
199
    Sync integration runtime credentials.
200
    
201
    Parameters:
202
    - resource_group_name (str): Name of the resource group
203
    - workspace_name (str): Name of the workspace
204
    - integration_runtime_name (str): Name of the integration runtime
205
    """
206
```
207

208
### Integration Runtime Node Management
209

210
Manage individual nodes within self-hosted integration runtimes.
211

212
```python { .api }
213
def get_node(resource_group_name: str, workspace_name: str, integration_runtime_name: str, node_name: str) -> SelfHostedIntegrationRuntimeNode:
214
    """
215
    Get integration runtime node.
216
    
217
    Parameters:
218
    - resource_group_name (str): Name of the resource group
219
    - workspace_name (str): Name of the workspace
220
    - integration_runtime_name (str): Name of the integration runtime
221
    - node_name (str): Name of the node
222
    
223
    Returns:
224
    SelfHostedIntegrationRuntimeNode: Integration runtime node
225
    """
226

227
def update_node(resource_group_name: str, workspace_name: str, integration_runtime_name: str, node_name: str, update_integration_runtime_node_request: UpdateIntegrationRuntimeNodeRequest) -> SelfHostedIntegrationRuntimeNode:
228
    """
229
    Update integration runtime node.
230
    
231
    Parameters:
232
    - resource_group_name (str): Name of the resource group
233
    - workspace_name (str): Name of the workspace
234
    - integration_runtime_name (str): Name of the integration runtime
235
    - node_name (str): Name of the node
236
    - update_integration_runtime_node_request (UpdateIntegrationRuntimeNodeRequest): Update parameters
237
    
238
    Returns:
239
    SelfHostedIntegrationRuntimeNode: Updated integration runtime node
240
    """
241

242
def delete_node(resource_group_name: str, workspace_name: str, integration_runtime_name: str, node_name: str) -> None:
243
    """
244
    Delete integration runtime node.
245
    
246
    Parameters:
247
    - resource_group_name (str): Name of the resource group
248
    - workspace_name (str): Name of the workspace
249
    - integration_runtime_name (str): Name of the integration runtime
250
    - node_name (str): Name of the node
251
    """
252

253
def get_node_ip_address(resource_group_name: str, workspace_name: str, integration_runtime_name: str, node_name: str) -> IntegrationRuntimeNodeIpAddress:
254
    """
255
    Get integration runtime node IP address.
256
    
257
    Parameters:
258
    - resource_group_name (str): Name of the resource group
259
    - workspace_name (str): Name of the workspace
260
    - integration_runtime_name (str): Name of the integration runtime
261
    - node_name (str): Name of the node
262
    
263
    Returns:
264
    IntegrationRuntimeNodeIpAddress: Node IP address
265
    """
266
```
267

268
### SSIS Object Metadata Management
269

270
Manage SSIS packages, projects, and environments for SQL Server Integration Services workloads.
271

272
```python { .api }
273
def get_ssis_object_metadata(resource_group_name: str, workspace_name: str, integration_runtime_name: str, get_ssis_object_metadata_request: GetSsisObjectMetadataRequest) -> SsisObjectMetadataListResponse:
274
    """
275
    Get SSIS object metadata.
276
    
277
    Parameters:
278
    - resource_group_name (str): Name of the resource group
279
    - workspace_name (str): Name of the workspace
280
    - integration_runtime_name (str): Name of the integration runtime
281
    - get_ssis_object_metadata_request (GetSsisObjectMetadataRequest): Metadata request parameters
282
    
283
    Returns:
284
    SsisObjectMetadataListResponse: SSIS object metadata
285
    """
286

287
def refresh_ssis_object_metadata(resource_group_name: str, workspace_name: str, integration_runtime_name: str) -> LROPoller[SsisObjectMetadataStatusResponse]:
288
    """
289
    Refresh SSIS object metadata.
290
    
291
    Parameters:
292
    - resource_group_name (str): Name of the resource group
293
    - workspace_name (str): Name of the workspace
294
    - integration_runtime_name (str): Name of the integration runtime
295
    
296
    Returns:
297
    LROPoller[SsisObjectMetadataStatusResponse]: Long-running operation poller
298
    """
299
```
300

301
## Types
302

303
### IntegrationRuntimeResource
304

305
```python { .api }
306
class IntegrationRuntimeResource:
307
    """
308
    Integration runtime resource.
309
    
310
    Attributes:
311
    - id (str): Resource ID
312
    - name (str): Resource name
313
    - type (str): Resource type
314
    - etag (str): Entity tag
315
    - properties (IntegrationRuntime): Integration runtime properties
316
    """
317
```
318

319
### IntegrationRuntime
320

321
```python { .api }
322
class IntegrationRuntime:
323
    """
324
    Base class for integration runtime.
325
    
326
    Attributes:
327
    - type (str): Integration runtime type
328
    - description (str): Integration runtime description
329
    """
330
```
331

332
### ManagedIntegrationRuntime
333

334
```python { .api }
335
class ManagedIntegrationRuntime:
336
    """
337
    Managed integration runtime.
338
    
339
    Attributes:
340
    - type (str): Integration runtime type
341
    - description (str): Integration runtime description
342
    - state (str): Integration runtime state
343
    - compute_properties (IntegrationRuntimeComputeProperties): Compute properties
344
    - ssis_properties (IntegrationRuntimeSsisProperties): SSIS properties
345
    """
346
```
347

348
### SelfHostedIntegrationRuntime
349

350
```python { .api }
351
class SelfHostedIntegrationRuntime:
352
    """
353
    Self-hosted integration runtime.
354
    
355
    Attributes:
356
    - type (str): Integration runtime type
357
    - description (str): Integration runtime description
358
    - linked_info (LinkedIntegrationRuntimeType): Linked integration runtime info
359
    """
360
```
361

362
### IntegrationRuntimeComputeProperties
363

364
```python { .api }
365
class IntegrationRuntimeComputeProperties:
366
    """
367
    Integration runtime compute properties.
368
    
369
    Attributes:
370
    - location (str): Compute location
371
    - node_size (str): Node size
372
    - number_of_nodes (int): Number of nodes
373
    - max_parallel_executions_per_node (int): Max parallel executions per node
374
    - data_flow_properties (IntegrationRuntimeDataFlowProperties): Data flow properties
375
    - v_net_properties (IntegrationRuntimeVNetProperties): VNet properties
376
    """
377
```
378

379
### IntegrationRuntimeSsisProperties
380

381
```python { .api }
382
class IntegrationRuntimeSsisProperties:
383
    """
384
    Integration runtime SSIS properties.
385
    
386
    Attributes:
387
    - catalog_info (IntegrationRuntimeSsisCatalogInfo): SSIS catalog info
388
    - license_type (str): License type
389
    - custom_setup_script_properties (IntegrationRuntimeCustomSetupScriptProperties): Custom setup script properties
390
    - data_proxy_properties (IntegrationRuntimeDataProxyProperties): Data proxy properties
391
    - edition (str): SSIS edition
392
    - express_custom_setup_properties (list): Express custom setup properties
393
    """
394
```
395

396
### IntegrationRuntimeStatusResponse
397

398
```python { .api }
399
class IntegrationRuntimeStatusResponse:
400
    """
401
    Integration runtime status response.
402
    
403
    Attributes:
404
    - name (str): Integration runtime name
405
    - properties (IntegrationRuntimeStatus): Status properties
406
    """
407
```
408

409
### IntegrationRuntimeAuthKeys
410

411
```python { .api }
412
class IntegrationRuntimeAuthKeys:
413
    """
414
    Integration runtime authentication keys.
415
    
416
    Attributes:
417
    - auth_key1 (str): Authentication key 1
418
    - auth_key2 (str): Authentication key 2
419
    """
420
```
421

422
### IntegrationRuntimeMonitoringData
423

424
```python { .api }
425
class IntegrationRuntimeMonitoringData:
426
    """
427
    Integration runtime monitoring data.
428
    
429
    Attributes:
430
    - name (str): Integration runtime name
431
    - nodes (list): Node monitoring data
432
    """
433
```
434

435
## Usage Examples
436

437
### Create Managed Integration Runtime
438

439
```python
440
from azure.mgmt.synapse.models import (
441
    IntegrationRuntimeResource, ManagedIntegrationRuntime,
442
    IntegrationRuntimeComputeProperties, IntegrationRuntimeDataFlowProperties
443
)
444

445
# Configure compute properties
446
data_flow_properties = IntegrationRuntimeDataFlowProperties(
447
    compute_type="General",
448
    core_count=8,
449
    time_to_live=10
450
)
451

452
compute_properties = IntegrationRuntimeComputeProperties(
453
    location="East US",
454
    node_size="Standard_D4_v2",
455
    number_of_nodes=2,
456
    max_parallel_executions_per_node=2,
457
    data_flow_properties=data_flow_properties
458
)
459

460
# Create managed integration runtime
461
managed_ir = ManagedIntegrationRuntime(
462
    type="Managed",
463
    description="Managed IR for data flows",
464
    compute_properties=compute_properties
465
)
466

467
ir_resource = IntegrationRuntimeResource(
468
    properties=managed_ir
469
)
470

471
operation = client.integration_runtimes.create(
472
    resource_group_name="my-resource-group",
473
    workspace_name="my-synapse-workspace",
474
    integration_runtime_name="my-managed-ir",
475
    integration_runtime=ir_resource
476
)
477

478
integration_runtime = operation.result()
479
print(f"Created integration runtime: {integration_runtime.name}")
480
```
481

482
### Create Self-Hosted Integration Runtime
483

484
```python
485
from azure.mgmt.synapse.models import (
486
    IntegrationRuntimeResource, SelfHostedIntegrationRuntime
487
)
488

489
# Create self-hosted integration runtime
490
self_hosted_ir = SelfHostedIntegrationRuntime(
491
    type="SelfHosted",
492
    description="Self-hosted IR for on-premises data"
493
)
494

495
ir_resource = IntegrationRuntimeResource(
496
    properties=self_hosted_ir
497
)
498

499
operation = client.integration_runtimes.create(
500
    resource_group_name="my-resource-group",
501
    workspace_name="my-synapse-workspace",
502
    integration_runtime_name="my-self-hosted-ir",
503
    integration_runtime=ir_resource
504
)
505

506
integration_runtime = operation.result()
507

508
# Get authentication keys for installation
509
auth_keys = client.integration_runtime_auth_keys.list_auth_keys(
510
    resource_group_name="my-resource-group",
511
    workspace_name="my-synapse-workspace",
512
    integration_runtime_name="my-self-hosted-ir"
513
)
514

515
print(f"Authentication Key 1: {auth_keys.auth_key1}")
516
print(f"Authentication Key 2: {auth_keys.auth_key2}")
517
```
518

519
### Monitor Integration Runtime
520

521
```python
522
# Get integration runtime status
523
status = client.integration_runtime_status.get_status(
524
    resource_group_name="my-resource-group",
525
    workspace_name="my-synapse-workspace",
526
    integration_runtime_name="my-managed-ir"
527
)
528

529
print(f"IR Status: {status.properties.state}")
530

531
# Get monitoring data
532
monitoring_data = client.integration_runtime_monitoring_data.get_monitoring_data(
533
    resource_group_name="my-resource-group",
534
    workspace_name="my-synapse-workspace",
535
    integration_runtime_name="my-managed-ir"
536
)
537

538
print(f"Node count: {len(monitoring_data.nodes)}")
539
for node in monitoring_data.nodes:
540
    print(f"Node: {node.node_name}, Status: {node.status}")
541
```