0
# Azure Container Registry Management Client
1

2
A comprehensive Python client library for managing Azure Container Registry resources through the Azure Resource Manager (ARM) API. This library enables developers to programmatically create, configure, and manage container registries, handle registry operations like replications, webhooks, and access policies, and integrate container registry management into Azure infrastructure automation workflows.
3

4
## Package Information
5

6
- **Package Name**: azure-mgmt-containerregistry
7
- **Package Type**: Python package (pip)
8
- **Language**: Python
9
- **Version**: 14.0.0
10
- **Installation**: `pip install azure-mgmt-containerregistry`
11
- **Documentation**: https://docs.microsoft.com/samples/browse/?languages=python&term=Getting%20started%20-%20Managing&terms=Getting%20started%20-%20Managing
12

13
## Core Imports
14

15
Main client import for multi-API version support:
16

17
```python
18
from azure.mgmt.containerregistry import ContainerRegistryManagementClient
19
```
20

21
Async client import:
22

23
```python
24
from azure.mgmt.containerregistry.aio import ContainerRegistryManagementClient
25
```
26

27
Specific API version import:
28

29
```python
30
from azure.mgmt.containerregistry.v2025_04_01 import ContainerRegistryManagementClient
31
```
32

33
Model imports:
34

35
```python
36
from azure.mgmt.containerregistry.models import (
37
    # Core registry models
38
    Registry,
39
    RegistryUpdateParameters,
40
    Sku,
41
    RegistryNameCheckRequest,
42
    RegistryNameStatus,
43
    RegistryListCredentialsResult,
44
    RegenerateCredentialParameters,
45
    ImportImageParameters,
46
    RegistryUsageListResult,
47
    GenerateCredentialsParameters,
48
    GenerateCredentialsResult,
49
    
50
    # Replication models
51
    Replication,
52
    ReplicationUpdateParameters,
53
    
54
    # Webhook models  
55
    Webhook,
56
    WebhookCreateParameters,
57
    WebhookUpdateParameters,
58
    CallbackConfig,
59
    Event,
60
    EventInfo,
61
    
62
    # Access control models
63
    ScopeMap,
64
    ScopeMapUpdateParameters,
65
    Token,
66
    TokenUpdateParameters,
67
    TokenCredentialsProperties,
68
    
69
    # Private networking models
70
    PrivateEndpointConnection,
71
    PrivateEndpoint,
72
    PrivateLinkServiceConnectionState,
73
    PrivateLinkResource,
74
    
75
    # Connected registry models
76
    ConnectedRegistry,
77
    ConnectedRegistryUpdateParameters,
78
    ActivationProperties,
79
    LoginServerProperties,
80
    
81
    # Cache and credentials models
82
    CacheRule,
83
    CacheRuleUpdateParameters,
84
    CredentialSet,
85
    CredentialSetUpdateParameters,
86
    AuthCredential,
87
    
88
    # Common enums
89
    ProvisioningState,
90
    WebhookAction,
91
    WebhookStatus,
92
    TokenStatus,
93
    ConnectionStatus,
94
    ConnectedRegistryMode,
95
    ZoneRedundancy
96
)
97
```
98

99
## Basic Usage
100

101
```python
102
from azure.identity import DefaultAzureCredential
103
from azure.mgmt.containerregistry import ContainerRegistryManagementClient
104

105
# Initialize client with Azure credentials
106
credential = DefaultAzureCredential()
107
subscription_id = "your-subscription-id"
108
client = ContainerRegistryManagementClient(credential, subscription_id)
109

110
# List all registries in subscription
111
registries = client.registries.list()
112
for registry in registries:
113
    print(f"Registry: {registry.name}, Location: {registry.location}")
114

115
# Get specific registry
116
registry = client.registries.get("resource-group-name", "registry-name")
117
print(f"Registry SKU: {registry.sku.name}")
118

119
# Create a basic registry
120
from azure.mgmt.containerregistry.models import Registry, Sku
121

122
registry_params = Registry(
123
    location="East US",
124
    sku=Sku(name="Standard"),
125
    admin_user_enabled=True
126
)
127

128
registry_creation = client.registries.begin_create(
129
    "resource-group-name",
130
    "new-registry-name", 
131
    registry_params
132
)
133
registry = registry_creation.result()  # Wait for completion
134
```
135

136
## Architecture
137

138
The client follows Azure SDK patterns with multi-API version support:
139

140
- **ContainerRegistryManagementClient**: Main multi-API client supporting all Azure clouds and API versions
141
- **Operation Groups**: Specialized classes for different functionality areas (registries, webhooks, replications, etc.)
142
- **Models**: Strongly-typed classes representing Azure resources and parameters
143
- **Long-Running Operations (LRO)**: Async pattern for operations that take time to complete
144
- **Multi-API Support**: Ability to target specific API versions for compatibility
145

146
The library supports both synchronous and asynchronous programming patterns and provides comprehensive coverage of Azure Container Registry management capabilities including advanced features like connected registries for edge scenarios, build automation, and sophisticated access control.
147

148
## Capabilities
149

150
### Registry Management
151

152
Core container registry lifecycle management including creation, configuration, updates, deletion, and administrative operations. Supports all registry SKUs (Basic, Standard, Premium) and advanced features like geo-replication and networking controls.
153

154
```python { .api }
155
class RegistriesOperations:
156
    def begin_create(resource_group_name: str, registry_name: str, registry: Registry, **kwargs) -> LROPoller[Registry]: ...
157
    def begin_delete(resource_group_name: str, registry_name: str, **kwargs) -> LROPoller[None]: ...
158
    def begin_update(resource_group_name: str, registry_name: str, registry_update_parameters: RegistryUpdateParameters, **kwargs) -> LROPoller[Registry]: ...
159
    def get(resource_group_name: str, registry_name: str, **kwargs) -> Registry: ...
160
    def list(**kwargs) -> ItemPaged[Registry]: ...
161
    def list_by_resource_group(resource_group_name: str, **kwargs) -> ItemPaged[Registry]: ...
162
    def check_name_availability(registry_name_check_request: RegistryNameCheckRequest, **kwargs) -> RegistryNameStatus: ...
163
    def list_credentials(resource_group_name: str, registry_name: str, **kwargs) -> RegistryListCredentialsResult: ...
164
    def regenerate_credential(resource_group_name: str, registry_name: str, regenerate_credential_parameters: RegenerateCredentialParameters, **kwargs) -> RegistryListCredentialsResult: ...
165
    def begin_import_image(resource_group_name: str, registry_name: str, parameters: ImportImageParameters, **kwargs) -> LROPoller[None]: ...
166
    def list_usages(resource_group_name: str, registry_name: str, **kwargs) -> RegistryUsageListResult: ...
167
    def list_private_link_resources(resource_group_name: str, registry_name: str, **kwargs) -> ItemPaged[PrivateLinkResource]: ...
168
    def get_private_link_resource(resource_group_name: str, registry_name: str, group_name: str, **kwargs) -> PrivateLinkResource: ...
169
    def begin_generate_credentials(resource_group_name: str, registry_name: str, generate_credentials_parameters: GenerateCredentialsParameters, **kwargs) -> LROPoller[GenerateCredentialsResult]: ...
170
```
171

172
[Registry Management](./registry-management.md)
173

174
### Replication Management
175

176
Geographic replication management for Premium registries, enabling registry content distribution across multiple Azure regions for performance and disaster recovery.
177

178
```python { .api }
179
class ReplicationsOperations:
180
    def begin_create(resource_group_name: str, registry_name: str, replication_name: str, replication: Replication, **kwargs) -> LROPoller[Replication]: ...
181
    def begin_delete(resource_group_name: str, registry_name: str, replication_name: str, **kwargs) -> LROPoller[None]: ...
182
    def begin_update(resource_group_name: str, registry_name: str, replication_name: str, replication_update_parameters: ReplicationUpdateParameters, **kwargs) -> LROPoller[Replication]: ...
183
    def get(resource_group_name: str, registry_name: str, replication_name: str, **kwargs) -> Replication: ...
184
    def list(resource_group_name: str, registry_name: str, **kwargs) -> ItemPaged[Replication]: ...
185
```
186

187
[Replication Management](./replication-management.md)
188

189
### Webhook Management
190

191
Registry webhook configuration for receiving notifications about registry events like image pushes, deletions, and quarantine actions. Supports custom endpoints and filtering.
192

193
```python { .api }
194
class WebhooksOperations:
195
    def begin_create(resource_group_name: str, registry_name: str, webhook_name: str, webhook_create_parameters: WebhookCreateParameters, **kwargs) -> LROPoller[Webhook]: ...
196
    def begin_delete(resource_group_name: str, registry_name: str, webhook_name: str, **kwargs) -> LROPoller[None]: ...
197
    def begin_update(resource_group_name: str, registry_name: str, webhook_name: str, webhook_update_parameters: WebhookUpdateParameters, **kwargs) -> LROPoller[Webhook]: ...
198
    def get(resource_group_name: str, registry_name: str, webhook_name: str, **kwargs) -> Webhook: ...
199
    def list(resource_group_name: str, registry_name: str, **kwargs) -> ItemPaged[Webhook]: ...
200
    def ping(resource_group_name: str, registry_name: str, webhook_name: str, **kwargs) -> EventInfo: ...
201
    def list_events(resource_group_name: str, registry_name: str, webhook_name: str, **kwargs) -> ItemPaged[Event]: ...
202
    def get_callback_config(resource_group_name: str, registry_name: str, webhook_name: str, **kwargs) -> CallbackConfig: ...
203
```
204

205
[Webhook Management](./webhook-management.md)
206

207
### Access Control
208

209
Repository-level access control through scope maps and tokens, providing fine-grained permissions for registry access without using admin credentials.
210

211
```python { .api }
212
class ScopeMapsOperations:
213
    def begin_create(resource_group_name: str, registry_name: str, scope_map_name: str, scope_map_create_parameters: ScopeMap, **kwargs) -> LROPoller[ScopeMap]: ...
214
    def begin_delete(resource_group_name: str, registry_name: str, scope_map_name: str, **kwargs) -> LROPoller[None]: ...
215
    def begin_update(resource_group_name: str, registry_name: str, scope_map_name: str, scope_map_update_parameters: ScopeMapUpdateParameters, **kwargs) -> LROPoller[ScopeMap]: ...
216
    def get(resource_group_name: str, registry_name: str, scope_map_name: str, **kwargs) -> ScopeMap: ...
217
    def list(resource_group_name: str, registry_name: str, **kwargs) -> ItemPaged[ScopeMap]: ...
218

219
class TokensOperations:
220
    def begin_create(resource_group_name: str, registry_name: str, token_name: str, token_create_parameters: Token, **kwargs) -> LROPoller[Token]: ...
221
    def begin_delete(resource_group_name: str, registry_name: str, token_name: str, **kwargs) -> LROPoller[None]: ...
222
    def begin_update(resource_group_name: str, registry_name: str, token_name: str, token_update_parameters: TokenUpdateParameters, **kwargs) -> LROPoller[Token]: ...
223
    def get(resource_group_name: str, registry_name: str, token_name: str, **kwargs) -> Token: ...
224
    def list(resource_group_name: str, registry_name: str, **kwargs) -> ItemPaged[Token]: ...
225
```
226

227
[Access Control](./access-control.md)
228

229
### Private Networking
230

231
Private endpoint connections for secure registry access through Azure Virtual Networks, supporting private connectivity and network isolation.
232

233
```python { .api }
234
class PrivateEndpointConnectionsOperations:
235
    def begin_create_or_update(resource_group_name: str, registry_name: str, private_endpoint_connection_name: str, private_endpoint_connection: PrivateEndpointConnection, **kwargs) -> LROPoller[PrivateEndpointConnection]: ...
236
    def begin_delete(resource_group_name: str, registry_name: str, private_endpoint_connection_name: str, **kwargs) -> LROPoller[None]: ...
237
    def get(resource_group_name: str, registry_name: str, private_endpoint_connection_name: str, **kwargs) -> PrivateEndpointConnection: ...
238
    def list(resource_group_name: str, registry_name: str, **kwargs) -> ItemPaged[PrivateEndpointConnection]: ...
239
```
240

241
[Private Networking](./private-networking.md)
242

243
### Connected Registries
244

245
Connected registry management for edge computing scenarios, enabling synchronized registry instances at edge locations with configurable sync policies.
246

247
```python { .api }
248
class ConnectedRegistriesOperations:
249
    def begin_create(resource_group_name: str, registry_name: str, connected_registry_name: str, connected_registry_create_parameters: ConnectedRegistry, **kwargs) -> LROPoller[ConnectedRegistry]: ...
250
    def begin_delete(resource_group_name: str, registry_name: str, connected_registry_name: str, **kwargs) -> LROPoller[None]: ...
251
    def begin_update(resource_group_name: str, registry_name: str, connected_registry_name: str, connected_registry_update_parameters: ConnectedRegistryUpdateParameters, **kwargs) -> LROPoller[ConnectedRegistry]: ...
252
    def begin_deactivate(resource_group_name: str, registry_name: str, connected_registry_name: str, **kwargs) -> LROPoller[None]: ...
253
    def get(resource_group_name: str, registry_name: str, connected_registry_name: str, **kwargs) -> ConnectedRegistry: ...
254
    def list(resource_group_name: str, registry_name: str, **kwargs) -> ItemPaged[ConnectedRegistry]: ...
255
```
256

257
[Connected Registries](./connected-registries.md)
258

259
### Cache and Credentials
260

261
Cache rule management for upstream registry caching and credential set management for secure authentication to external registries.
262

263
```python { .api }
264
class CacheRulesOperations:
265
    def begin_create(resource_group_name: str, registry_name: str, cache_rule_name: str, cache_rule_create_parameters: CacheRule, **kwargs) -> LROPoller[CacheRule]: ...
266
    def begin_delete(resource_group_name: str, registry_name: str, cache_rule_name: str, **kwargs) -> LROPoller[None]: ...
267
    def begin_update(resource_group_name: str, registry_name: str, cache_rule_name: str, cache_rule_update_parameters: CacheRuleUpdateParameters, **kwargs) -> LROPoller[CacheRule]: ...
268
    def get(resource_group_name: str, registry_name: str, cache_rule_name: str, **kwargs) -> CacheRule: ...
269
    def list(resource_group_name: str, registry_name: str, **kwargs) -> ItemPaged[CacheRule]: ...
270

271
class CredentialSetsOperations:
272
    def begin_create(resource_group_name: str, registry_name: str, credential_set_name: str, credential_set_create_parameters: CredentialSet, **kwargs) -> LROPoller[CredentialSet]: ...
273
    def begin_delete(resource_group_name: str, registry_name: str, credential_set_name: str, **kwargs) -> LROPoller[None]: ...
274
    def begin_update(resource_group_name: str, registry_name: str, credential_set_name: str, credential_set_update_parameters: CredentialSetUpdateParameters, **kwargs) -> LROPoller[CredentialSet]: ...
275
    def get(resource_group_name: str, registry_name: str, credential_set_name: str, **kwargs) -> CredentialSet: ...
276
    def list(resource_group_name: str, registry_name: str, **kwargs) -> ItemPaged[CredentialSet]: ...
277
```
278

279
[Cache and Credentials](./cache-and-credentials.md)