0
# Registry Management
1

2
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, networking controls, encryption, and content trust policies.
3

4
## Capabilities
5

6
### Registry Creation and Management
7

8
Create, update, and delete Azure Container Registries with comprehensive configuration options including SKU selection, administrative settings, and advanced features.
9

10
```python { .api }
11
def begin_create(resource_group_name: str, registry_name: str, registry: Registry, **kwargs) -> LROPoller[Registry]:
12
    """
13
    Create or update a container registry.
14
    
15
    Parameters:
16
    - resource_group_name: str - Name of the resource group
17
    - registry_name: str - Name of the registry
18
    - registry: Registry - Registry resource parameters
19
    
20
    Returns:
21
    LROPoller[Registry] - Long-running operation poller for the registry
22
    """
23

24
def begin_delete(resource_group_name: str, registry_name: str, **kwargs) -> LROPoller[None]:
25
    """
26
    Delete a container registry.
27
    
28
    Parameters:
29
    - resource_group_name: str - Name of the resource group
30
    - registry_name: str - Name of the registry
31
    
32
    Returns:
33
    LROPoller[None] - Long-running operation poller
34
    """
35

36
def begin_update(resource_group_name: str, registry_name: str, registry_update_parameters: RegistryUpdateParameters, **kwargs) -> LROPoller[Registry]:
37
    """
38
    Update a container registry.
39
    
40
    Parameters:
41
    - resource_group_name: str - Name of the resource group
42
    - registry_name: str - Name of the registry
43
    - registry_update_parameters: RegistryUpdateParameters - Registry update parameters
44
    
45
    Returns:
46
    LROPoller[Registry] - Long-running operation poller for the updated registry
47
    """
48
```
49

50
### Registry Information and Status
51

52
Retrieve registry details, list registries, and check registry status and configuration.
53

54
```python { .api }
55
def get(resource_group_name: str, registry_name: str, **kwargs) -> Registry:
56
    """
57
    Get properties of a container registry.
58
    
59
    Parameters:
60
    - resource_group_name: str - Name of the resource group
61
    - registry_name: str - Name of the registry
62
    
63
    Returns:
64
    Registry - Registry resource with complete configuration
65
    """
66

67
def list(**kwargs) -> ItemPaged[Registry]:
68
    """
69
    List all container registries in the subscription.
70
    
71
    Returns:
72
    ItemPaged[Registry] - Paginated list of all registries
73
    """
74

75
def list_by_resource_group(resource_group_name: str, **kwargs) -> ItemPaged[Registry]:
76
    """
77
    List all container registries in a resource group.
78
    
79
    Parameters:
80
    - resource_group_name: str - Name of the resource group
81
    
82
    Returns:
83
    ItemPaged[Registry] - Paginated list of registries in the resource group
84
    """
85
```
86

87
### Name Availability and Validation
88

89
Check registry name availability before creation to ensure unique naming requirements are met.
90

91
```python { .api }
92
def check_name_availability(registry_name_check_request: RegistryNameCheckRequest, **kwargs) -> RegistryNameStatus:
93
    """
94
    Check if a registry name is available for use.
95
    
96
    Parameters:
97
    - registry_name_check_request: RegistryNameCheckRequest - Name availability check request
98
    
99
    Returns:
100
    RegistryNameStatus - Name availability result with reason if unavailable
101
    """
102
```
103

104
### Administrative Credentials
105

106
Manage registry admin credentials for direct Docker CLI access, including credential retrieval and regeneration.
107

108
```python { .api }
109
def list_credentials(resource_group_name: str, registry_name: str, **kwargs) -> RegistryListCredentialsResult:
110
    """
111
    List admin credentials for a container registry.
112
    
113
    Parameters:
114
    - resource_group_name: str - Name of the resource group
115
    - registry_name: str - Name of the registry
116
    
117
    Returns:
118
    RegistryListCredentialsResult - Registry admin username and passwords
119
    """
120

121
def regenerate_credential(resource_group_name: str, registry_name: str, regenerate_credential_parameters: RegenerateCredentialParameters, **kwargs) -> RegistryListCredentialsResult:
122
    """
123
    Regenerate one of the admin passwords for a container registry.
124
    
125
    Parameters:
126
    - resource_group_name: str - Name of the resource group
127
    - registry_name: str - Name of the registry
128
    - regenerate_credential_parameters: RegenerateCredentialParameters - Password name to regenerate
129
    
130
    Returns:
131
    RegistryListCredentialsResult - Updated registry credentials
132
    """
133

134
def begin_generate_credentials(resource_group_name: str, registry_name: str, generate_credentials_parameters: GenerateCredentialsParameters, **kwargs) -> LROPoller[GenerateCredentialsResult]:
135
    """
136
    Generate credentials for a container registry with the specified parameters.
137
    
138
    Parameters:
139
    - resource_group_name: str - Name of the resource group
140
    - registry_name: str - Name of the registry
141
    - generate_credentials_parameters: GenerateCredentialsParameters - Credential generation parameters
142
    
143
    Returns:
144
    LROPoller[GenerateCredentialsResult] - Long-running operation for credential generation
145
    """
146
```
147

148
### Usage Metrics and Monitoring
149

150
Retrieve registry usage information including storage utilization and webhook count metrics.
151

152
```python { .api }
153
def list_usages(resource_group_name: str, registry_name: str, **kwargs) -> RegistryUsageListResult:
154
    """
155
    Get quota usages for a container registry.
156
    
157
    Parameters:
158
    - resource_group_name: str - Name of the resource group
159
    - registry_name: str - Name of the registry
160
    
161
    Returns:
162
    RegistryUsageListResult - Current usage metrics for the registry
163
    """
164
```
165

166
### Image Import Operations
167

168
Import container images from external registries or other Azure Container Registries.
169

170
```python { .api }
171
def begin_import_image(resource_group_name: str, registry_name: str, parameters: ImportImageParameters, **kwargs) -> LROPoller[None]:
172
    """
173
    Copy an image from another registry into this registry.
174
    
175
    Parameters:
176
    - resource_group_name: str - Name of the resource group
177
    - registry_name: str - Name of the registry
178
    - parameters: ImportImageParameters - Import operation parameters
179
    
180
    Returns:
181
    LROPoller[None] - Long-running operation poller for the import
182
    """
183
```
184

185
### Private Link Resources
186

187
Manage private link resources for private endpoint connectivity to the registry.
188

189
```python { .api }
190
def list_private_link_resources(resource_group_name: str, registry_name: str, **kwargs) -> PrivateLinkResourceListResult:
191
    """
192
    List private link resources for a container registry.
193
    
194
    Parameters:
195
    - resource_group_name: str - Name of the resource group
196
    - registry_name: str - Name of the registry
197
    
198
    Returns:
199
    PrivateLinkResourceListResult - Available private link resources
200
    """
201

202
def get_private_link_resource(resource_group_name: str, registry_name: str, group_name: str, **kwargs) -> PrivateLinkResource:
203
    """
204
    Get a private link resource by name for a container registry.
205
    
206
    Parameters:
207
    - resource_group_name: str - Name of the resource group
208
    - registry_name: str - Name of the registry
209
    - group_name: str - Name of the private link resource
210
    
211
    Returns:
212
    PrivateLinkResource - Private link resource details
213
    """
214
```
215

216
## Core Model Types
217

218
### Registry
219

220
```python { .api }
221
class Registry:
222
    """
223
    An object that represents a container registry.
224
    
225
    Attributes:
226
    - id: str - Resource ID
227
    - name: str - Resource name
228
    - type: str - Resource type
229
    - location: str - Resource location
230
    - tags: Dict[str, str] - Resource tags
231
    - sku: Sku - Registry SKU configuration
232
    - login_server: str - Registry login server URL
233
    - creation_date: datetime - Creation timestamp
234
    - provisioning_state: ProvisioningState - Current provisioning state
235
    - status: Status - Registry status information
236
    - admin_user_enabled: bool - Enable admin user account
237
    - storage_account: StorageAccountProperties - Storage account details (Legacy)
238
    - network_rule_set: NetworkRuleSet - Network access rules
239
    - policies: Policies - Registry policies configuration
240
    - encryption: EncryptionProperty - Encryption configuration
241
    - data_endpoint_enabled: bool - Enable dedicated data endpoints
242
    - data_endpoint_host_names: List[str] - Data endpoint host names
243
    - private_endpoint_connections: List[PrivateEndpointConnection] - Private endpoints
244
    - public_network_access: PublicNetworkAccess - Public network access setting
245
    - network_rule_bypass_options: NetworkRuleBypassOptions - Network rule bypass
246
    - zone_redundancy: ZoneRedundancy - Zone redundancy setting
247
    - anonymous_pull_enabled: bool - Enable anonymous pull
248
    """
249
```
250

251
### RegistryUpdateParameters
252

253
```python { .api }
254
class RegistryUpdateParameters:
255
    """
256
    Parameters for updating a container registry.
257
    
258
    Attributes:
259
    - tags: Dict[str, str] - Resource tags
260
    - sku: Sku - Registry SKU
261
    - admin_user_enabled: bool - Enable admin user
262
    - network_rule_set: NetworkRuleSet - Network access rules
263
    - policies: Policies - Registry policies
264
    - encryption: EncryptionProperty - Encryption settings
265
    - data_endpoint_enabled: bool - Enable data endpoints
266
    - public_network_access: PublicNetworkAccess - Public access setting
267
    - network_rule_bypass_options: NetworkRuleBypassOptions - Network bypass options
268
    - anonymous_pull_enabled: bool - Enable anonymous pull
269
    """
270
```
271

272
### Sku
273

274
```python { .api }
275
class Sku:
276
    """
277
    SKU properties of a container registry.
278
    
279
    Attributes:
280
    - name: SkuName - SKU name (Basic, Standard, Premium)
281
    - tier: SkuTier - SKU tier (Basic, Standard, Premium)
282
    """
283
```
284

285
### RegistryNameCheckRequest
286

287
```python { .api }
288
class RegistryNameCheckRequest:
289
    """
290
    Request to check registry name availability.
291
    
292
    Attributes:
293
    - name: str - Registry name to check
294
    - type: str - Resource type (always 'Microsoft.ContainerRegistry/registries')
295
    """
296
```
297

298
### RegistryNameStatus
299

300
```python { .api }
301
class RegistryNameStatus:
302
    """
303
    Result of registry name availability check.
304
    
305
    Attributes:
306
    - name_available: bool - Whether the name is available
307
    - reason: str - Reason if name is unavailable
308
    - message: str - Detailed message about availability
309
    """
310
```
311

312
### ImportImageParameters
313

314
```python { .api }
315
class ImportImageParameters:
316
    """
317
    Parameters for importing an image.
318
    
319
    Attributes:
320
    - source: ImportSource - Source registry information
321
    - target_tags: List[str] - Target tags for the imported image
322
    - target_repository: str - Target repository name
323
    - untagged_target_repositories: List[str] - Repositories for untagged imports
324
    - mode: ImportMode - Import mode (NoForce, Force)
325
    """
326
```
327

328
### GenerateCredentialsParameters
329

330
```python { .api }
331
class GenerateCredentialsParameters:
332
    """
333
    Parameters for generating credentials.
334
    
335
    Attributes:
336
    - token_id: str - Token ID for credential generation
337
    - expiry: datetime - Credential expiry time
338
    - name: TokenPasswordName - Password name (password1, password2)
339
    """
340
```
341

342
## Usage Examples
343

344
### Create a Premium Registry with Advanced Features
345

346
```python
347
from azure.mgmt.containerregistry import ContainerRegistryManagementClient
348
from azure.mgmt.containerregistry.models import (
349
    Registry, Sku, SkuName, NetworkRuleSet, DefaultAction,
350
    EncryptionProperty, KeyVaultProperties, Policies, TrustPolicy, PolicyStatus
351
)
352
from azure.identity import DefaultAzureCredential
353

354
client = ContainerRegistryManagementClient(
355
    DefaultAzureCredential(), 
356
    "subscription-id"
357
)
358

359
# Create a Premium registry with advanced features
360
registry_params = Registry(
361
    location="East US",
362
    sku=Sku(name=SkuName.PREMIUM),
363
    admin_user_enabled=False,
364
    network_rule_set=NetworkRuleSet(
365
        default_action=DefaultAction.DENY,
366
        ip_rules=[
367
            {"action": "Allow", "ip_address_or_range": "203.0.113.0/24"}
368
        ]
369
    ),
370
    policies=Policies(
371
        trust_policy=TrustPolicy(
372
            type="Notary",
373
            status=PolicyStatus.ENABLED
374
        )
375
    ),
376
    public_network_access="Disabled",
377
    zone_redundancy="Enabled"
378
)
379

380
# Start registry creation
381
creation_poller = client.registries.begin_create(
382
    "my-resource-group",
383
    "my-premium-registry",
384
    registry_params
385
)
386

387
# Wait for completion
388
registry = creation_poller.result()
389
print(f"Created registry: {registry.login_server}")
390
```
391

392
### Manage Registry Credentials
393

394
```python
395
# Get current admin credentials
396
credentials = client.registries.list_credentials(
397
    "my-resource-group", 
398
    "my-registry"
399
)
400
print(f"Username: {credentials.username}")
401
print(f"Password 1: {credentials.passwords[0].value}")
402

403
# Regenerate password2
404
from azure.mgmt.containerregistry.models import RegenerateCredentialParameters, PasswordName
405

406
regen_params = RegenerateCredentialParameters(name=PasswordName.PASSWORD2)
407
new_credentials = client.registries.regenerate_credential(
408
    "my-resource-group",
409
    "my-registry", 
410
    regen_params
411
)
412
print(f"New password 2: {new_credentials.passwords[1].value}")
413
```
414

415
### Import Image from Another Registry
416

417
```python
418
from azure.mgmt.containerregistry.models import ImportImageParameters, ImportSource
419

420
import_params = ImportImageParameters(
421
    source=ImportSource(
422
        registry_uri="mcr.microsoft.com",
423
        source_image="dotnet/runtime:6.0"
424
    ),
425
    target_tags=["dotnet/runtime:6.0", "dotnet/runtime:latest"],
426
    mode="NoForce"
427
)
428

429
import_poller = client.registries.begin_import_image(
430
    "my-resource-group",
431
    "my-registry",
432
    import_params
433
)
434

435
import_poller.result()  # Wait for import completion
436
print("Image import completed successfully")
437
```