pulumi-azure-kotlin/com.pulumi.azure.containerservice.kotlin/RegistryArgs

RegistryArgs

data class RegistryArgs(val adminEnabled: Output<Boolean>? = null, val anonymousPullEnabled: Output<Boolean>? = null, val dataEndpointEnabled: Output<Boolean>? = null, val encryption: Output<RegistryEncryptionArgs>? = null, val exportPolicyEnabled: Output<Boolean>? = null, val georeplications: Output<List<RegistryGeoreplicationArgs>>? = null, val identity: Output<RegistryIdentityArgs>? = null, val location: Output<String>? = null, val name: Output<String>? = null, val networkRuleBypassOption: Output<String>? = null, val networkRuleSet: Output<RegistryNetworkRuleSetArgs>? = null, val publicNetworkAccessEnabled: Output<Boolean>? = null, val quarantinePolicyEnabled: Output<Boolean>? = null, val resourceGroupName: Output<String>? = null, val retentionPolicyInDays: Output<Int>? = null, val sku: Output<String>? = null, val tags: Output<Map<String, String>>? = null, val trustPolicyEnabled: Output<Boolean>? = null, val zoneRedundancyEnabled: Output<Boolean>? = null) : ConvertibleToJava<RegistryArgs>

Manages an Azure Container Registry.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const acr = new azure.containerservice.Registry("acr", {
    name: "containerRegistry1",
    resourceGroupName: example.name,
    location: example.location,
    sku: "Premium",
    adminEnabled: false,
    georeplications: [
        {
            location: "East US",
            zoneRedundancyEnabled: true,
            tags: {},
        },
        {
            location: "North Europe",
            zoneRedundancyEnabled: true,
            tags: {},
        },
    ],
});
Content copied to clipboard
import pulumi
import pulumi_azure as azure
example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
acr = azure.containerservice.Registry("acr",
    name="containerRegistry1",
    resource_group_name=example.name,
    location=example.location,
    sku="Premium",
    admin_enabled=False,
    georeplications=[
        {
            "location": "East US",
            "zone_redundancy_enabled": True,
            "tags": {},
        },
        {
            "location": "North Europe",
            "zone_redundancy_enabled": True,
            "tags": {},
        },
    ])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });
    var acr = new Azure.ContainerService.Registry("acr", new()
    {
        Name = "containerRegistry1",
        ResourceGroupName = example.Name,
        Location = example.Location,
        Sku = "Premium",
        AdminEnabled = false,
        Georeplications = new[]
        {
            new Azure.ContainerService.Inputs.RegistryGeoreplicationArgs
            {
                Location = "East US",
                ZoneRedundancyEnabled = true,
                Tags = null,
            },
            new Azure.ContainerService.Inputs.RegistryGeoreplicationArgs
            {
                Location = "North Europe",
                ZoneRedundancyEnabled = true,
                Tags = null,
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/containerservice"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		_, err = containerservice.NewRegistry(ctx, "acr", &containerservice.RegistryArgs{
			Name:              pulumi.String("containerRegistry1"),
			ResourceGroupName: example.Name,
			Location:          example.Location,
			Sku:               pulumi.String("Premium"),
			AdminEnabled:      pulumi.Bool(false),
			Georeplications: containerservice.RegistryGeoreplicationArray{
				&containerservice.RegistryGeoreplicationArgs{
					Location:              pulumi.String("East US"),
					ZoneRedundancyEnabled: pulumi.Bool(true),
					Tags:                  pulumi.StringMap{},
				},
				&containerservice.RegistryGeoreplicationArgs{
					Location:              pulumi.String("North Europe"),
					ZoneRedundancyEnabled: pulumi.Bool(true),
					Tags:                  pulumi.StringMap{},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.containerservice.Registry;
import com.pulumi.azure.containerservice.RegistryArgs;
import com.pulumi.azure.containerservice.inputs.RegistryGeoreplicationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("West Europe")
            .build());
        var acr = new Registry("acr", RegistryArgs.builder()
            .name("containerRegistry1")
            .resourceGroupName(example.name())
            .location(example.location())
            .sku("Premium")
            .adminEnabled(false)
            .georeplications(
                RegistryGeoreplicationArgs.builder()
                    .location("East US")
                    .zoneRedundancyEnabled(true)
                    .tags()
                    .build(),
                RegistryGeoreplicationArgs.builder()
                    .location("North Europe")
                    .zoneRedundancyEnabled(true)
                    .tags()
                    .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: West Europe
  acr:
    type: azure:containerservice:Registry
    properties:
      name: containerRegistry1
      resourceGroupName: ${example.name}
      location: ${example.location}
      sku: Premium
      adminEnabled: false
      georeplications:
        - location: East US
          zoneRedundancyEnabled: true
          tags: {}
        - location: North Europe
          zoneRedundancyEnabled: true
          tags: {}
Content copied to clipboard

Encryption)

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const exampleResourceGroup = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const exampleUserAssignedIdentity = new azure.authorization.UserAssignedIdentity("example", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    name: "registry-uai",
});
const example = azure.keyvault.getKey({
    name: "super-secret",
    keyVaultId: existing.id,
});
const acr = new azure.containerservice.Registry("acr", {
    name: "containerRegistry1",
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    sku: "Premium",
    identity: {
        type: "UserAssigned",
        identityIds: [exampleUserAssignedIdentity&#46;id],
    },
    encryption: {
        keyVaultKeyId: example.then(example => example.id),
        identityClientId: exampleUserAssignedIdentity.clientId,
    },
});
Content copied to clipboard
import pulumi
import pulumi_azure as azure
example_resource_group = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
example_user_assigned_identity = azure.authorization.UserAssignedIdentity("example",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    name="registry-uai")
example = azure.keyvault.get_key(name="super-secret",
    key_vault_id=existing["id"])
acr = azure.containerservice.Registry("acr",
    name="containerRegistry1",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    sku="Premium",
    identity={
        "type": "UserAssigned",
        "identity_ids": [example_user_assigned_identity&#46;id],
    },
    encryption={
        "key_vault_key_id": example.id,
        "identity_client_id": example_user_assigned_identity.client_id,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var exampleResourceGroup = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });
    var exampleUserAssignedIdentity = new Azure.Authorization.UserAssignedIdentity("example", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        Name = "registry-uai",
    });
    var example = Azure.KeyVault.GetKey.Invoke(new()
    {
        Name = "super-secret",
        KeyVaultId = existing.Id,
    });
    var acr = new Azure.ContainerService.Registry("acr", new()
    {
        Name = "containerRegistry1",
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        Sku = "Premium",
        Identity = new Azure.ContainerService.Inputs.RegistryIdentityArgs
        {
            Type = "UserAssigned",
            IdentityIds = new[]
            {
                exampleUserAssignedIdentity.Id,
            },
        },
        Encryption = new Azure.ContainerService.Inputs.RegistryEncryptionArgs
        {
            KeyVaultKeyId = example.Apply(getKeyResult => getKeyResult.Id),
            IdentityClientId = exampleUserAssignedIdentity.ClientId,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/containerservice"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/keyvault"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleUserAssignedIdentity, err := authorization.NewUserAssignedIdentity(ctx, "example", &authorization.UserAssignedIdentityArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Name:              pulumi.String("registry-uai"),
		})
		if err != nil {
			return err
		}
		example, err := keyvault.LookupKey(ctx, &keyvault.LookupKeyArgs{
			Name:       "super-secret",
			KeyVaultId: existing.Id,
		}, nil)
		if err != nil {
			return err
		}
		_, err = containerservice.NewRegistry(ctx, "acr", &containerservice.RegistryArgs{
			Name:              pulumi.String("containerRegistry1"),
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku:               pulumi.String("Premium"),
			Identity: &containerservice.RegistryIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				IdentityIds: pulumi.StringArray{
					exampleUserAssignedIdentity.ID(),
				},
			},
			Encryption: &containerservice.RegistryEncryptionArgs{
				KeyVaultKeyId:    pulumi.String(example.Id),
				IdentityClientId: exampleUserAssignedIdentity.ClientId,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.authorization.UserAssignedIdentity;
import com.pulumi.azure.authorization.UserAssignedIdentityArgs;
import com.pulumi.azure.keyvault.KeyvaultFunctions;
import com.pulumi.azure.keyvault.inputs.GetKeyArgs;
import com.pulumi.azure.containerservice.Registry;
import com.pulumi.azure.containerservice.RegistryArgs;
import com.pulumi.azure.containerservice.inputs.RegistryIdentityArgs;
import com.pulumi.azure.containerservice.inputs.RegistryEncryptionArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("West Europe")
            .build());
        var exampleUserAssignedIdentity = new UserAssignedIdentity("exampleUserAssignedIdentity", UserAssignedIdentityArgs.builder()
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .name("registry-uai")
            .build());
        final var example = KeyvaultFunctions.getKey(GetKeyArgs.builder()
            .name("super-secret")
            .keyVaultId(existing.id())
            .build());
        var acr = new Registry("acr", RegistryArgs.builder()
            .name("containerRegistry1")
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .sku("Premium")
            .identity(RegistryIdentityArgs.builder()
                .type("UserAssigned")
                .identityIds(exampleUserAssignedIdentity.id())
                .build())
            .encryption(RegistryEncryptionArgs.builder()
                .keyVaultKeyId(example.applyValue(getKeyResult -> getKeyResult.id()))
                .identityClientId(exampleUserAssignedIdentity.clientId())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    name: example
    properties:
      name: example-resources
      location: West Europe
  acr:
    type: azure:containerservice:Registry
    properties:
      name: containerRegistry1
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
      sku: Premium
      identity:
        type: UserAssigned
        identityIds:
          - ${exampleUserAssignedIdentity.id}
      encryption:
        keyVaultKeyId: ${example.id}
        identityClientId: ${exampleUserAssignedIdentity.clientId}
  exampleUserAssignedIdentity:
    type: azure:authorization:UserAssignedIdentity
    name: example
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
      name: registry-uai
variables:
  example:
    fn::invoke:
      function: azure:keyvault:getKey
      arguments:
        name: super-secret
        keyVaultId: ${existing.id}
Content copied to clipboard

Attaching A Container Registry To A Kubernetes Cluster)

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const exampleRegistry = new azure.containerservice.Registry("example", {
    name: "containerRegistry1",
    resourceGroupName: example.name,
    location: example.location,
    sku: "Premium",
});
const exampleKubernetesCluster = new azure.containerservice.KubernetesCluster("example", {
    name: "example-aks1",
    location: example.location,
    resourceGroupName: example.name,
    dnsPrefix: "exampleaks1",
    defaultNodePool: {
        name: "default",
        nodeCount: 1,
        vmSize: "Standard_D2_v2",
    },
    identity: {
        type: "SystemAssigned",
    },
    tags: {
        Environment: "Production",
    },
});
const exampleAssignment = new azure.authorization.Assignment("example", {
    principalId: exampleKubernetesCluster.kubeletIdentity.apply(kubeletIdentity => kubeletIdentity.objectId),
    roleDefinitionName: "AcrPull",
    scope: exampleRegistry.id,
    skipServicePrincipalAadCheck: true,
});
Content copied to clipboard
import pulumi
import pulumi_azure as azure
example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
example_registry = azure.containerservice.Registry("example",
    name="containerRegistry1",
    resource_group_name=example.name,
    location=example.location,
    sku="Premium")
example_kubernetes_cluster = azure.containerservice.KubernetesCluster("example",
    name="example-aks1",
    location=example.location,
    resource_group_name=example.name,
    dns_prefix="exampleaks1",
    default_node_pool={
        "name": "default",
        "node_count": 1,
        "vm_size": "Standard_D2_v2",
    },
    identity={
        "type": "SystemAssigned",
    },
    tags={
        "Environment": "Production",
    })
example_assignment = azure.authorization.Assignment("example",
    principal_id=example_kubernetes_cluster.kubelet_identity.object_id,
    role_definition_name="AcrPull",
    scope=example_registry.id,
    skip_service_principal_aad_check=True)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });
    var exampleRegistry = new Azure.ContainerService.Registry("example", new()
    {
        Name = "containerRegistry1",
        ResourceGroupName = example.Name,
        Location = example.Location,
        Sku = "Premium",
    });
    var exampleKubernetesCluster = new Azure.ContainerService.KubernetesCluster("example", new()
    {
        Name = "example-aks1",
        Location = example.Location,
        ResourceGroupName = example.Name,
        DnsPrefix = "exampleaks1",
        DefaultNodePool = new Azure.ContainerService.Inputs.KubernetesClusterDefaultNodePoolArgs
        {
            Name = "default",
            NodeCount = 1,
            VmSize = "Standard_D2_v2",
        },
        Identity = new Azure.ContainerService.Inputs.KubernetesClusterIdentityArgs
        {
            Type = "SystemAssigned",
        },
        Tags =
        {
            { "Environment", "Production" },
        },
    });
    var exampleAssignment = new Azure.Authorization.Assignment("example", new()
    {
        PrincipalId = exampleKubernetesCluster.KubeletIdentity.Apply(kubeletIdentity => kubeletIdentity.ObjectId),
        RoleDefinitionName = "AcrPull",
        Scope = exampleRegistry.Id,
        SkipServicePrincipalAadCheck = true,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/containerservice"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleRegistry, err := containerservice.NewRegistry(ctx, "example", &containerservice.RegistryArgs{
			Name:              pulumi.String("containerRegistry1"),
			ResourceGroupName: example.Name,
			Location:          example.Location,
			Sku:               pulumi.String("Premium"),
		})
		if err != nil {
			return err
		}
		exampleKubernetesCluster, err := containerservice.NewKubernetesCluster(ctx, "example", &containerservice.KubernetesClusterArgs{
			Name:              pulumi.String("example-aks1"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			DnsPrefix:         pulumi.String("exampleaks1"),
			DefaultNodePool: &containerservice.KubernetesClusterDefaultNodePoolArgs{
				Name:      pulumi.String("default"),
				NodeCount: pulumi.Int(1),
				VmSize:    pulumi.String("Standard_D2_v2"),
			},
			Identity: &containerservice.KubernetesClusterIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("Production"),
			},
		})
		if err != nil {
			return err
		}
		_, err = authorization.NewAssignment(ctx, "example", &authorization.AssignmentArgs{
			PrincipalId: pulumi.String(exampleKubernetesCluster.KubeletIdentity.ApplyT(func(kubeletIdentity containerservice.KubernetesClusterKubeletIdentity) (*string, error) {
				return &kubeletIdentity.ObjectId, nil
			}).(pulumi.StringPtrOutput)),
			RoleDefinitionName:           pulumi.String("AcrPull"),
			Scope:                        exampleRegistry.ID(),
			SkipServicePrincipalAadCheck: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.containerservice.Registry;
import com.pulumi.azure.containerservice.RegistryArgs;
import com.pulumi.azure.containerservice.KubernetesCluster;
import com.pulumi.azure.containerservice.KubernetesClusterArgs;
import com.pulumi.azure.containerservice.inputs.KubernetesClusterDefaultNodePoolArgs;
import com.pulumi.azure.containerservice.inputs.KubernetesClusterIdentityArgs;
import com.pulumi.azure.authorization.Assignment;
import com.pulumi.azure.authorization.AssignmentArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("West Europe")
            .build());
        var exampleRegistry = new Registry("exampleRegistry", RegistryArgs.builder()
            .name("containerRegistry1")
            .resourceGroupName(example.name())
            .location(example.location())
            .sku("Premium")
            .build());
        var exampleKubernetesCluster = new KubernetesCluster("exampleKubernetesCluster", KubernetesClusterArgs.builder()
            .name("example-aks1")
            .location(example.location())
            .resourceGroupName(example.name())
            .dnsPrefix("exampleaks1")
            .defaultNodePool(KubernetesClusterDefaultNodePoolArgs.builder()
                .name("default")
                .nodeCount(1)
                .vmSize("Standard_D2_v2")
                .build())
            .identity(KubernetesClusterIdentityArgs.builder()
                .type("SystemAssigned")
                .build())
            .tags(Map.of("Environment", "Production"))
            .build());
        var exampleAssignment = new Assignment("exampleAssignment", AssignmentArgs.builder()
            .principalId(exampleKubernetesCluster.kubeletIdentity().applyValue(kubeletIdentity -> kubeletIdentity.objectId()))
            .roleDefinitionName("AcrPull")
            .scope(exampleRegistry.id())
            .skipServicePrincipalAadCheck(true)
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: West Europe
  exampleRegistry:
    type: azure:containerservice:Registry
    name: example
    properties:
      name: containerRegistry1
      resourceGroupName: ${example.name}
      location: ${example.location}
      sku: Premium
  exampleKubernetesCluster:
    type: azure:containerservice:KubernetesCluster
    name: example
    properties:
      name: example-aks1
      location: ${example.location}
      resourceGroupName: ${example.name}
      dnsPrefix: exampleaks1
      defaultNodePool:
        name: default
        nodeCount: 1
        vmSize: Standard_D2_v2
      identity:
        type: SystemAssigned
      tags:
        Environment: Production
  exampleAssignment:
    type: azure:authorization:Assignment
    name: example
    properties:
      principalId: ${exampleKubernetesCluster.kubeletIdentity.objectId}
      roleDefinitionName: AcrPull
      scope: ${exampleRegistry.id}
      skipServicePrincipalAadCheck: true
Content copied to clipboard

Import

Container Registries can be imported using the resource id, e.g.

$ pulumi import azure:containerservice/registry:Registry example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.ContainerRegistry/registries/myregistry1
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(adminEnabled: Output<Boolean>? = null, anonymousPullEnabled: Output<Boolean>? = null, dataEndpointEnabled: Output<Boolean>? = null, encryption: Output<RegistryEncryptionArgs>? = null, exportPolicyEnabled: Output<Boolean>? = null, georeplications: Output<List<RegistryGeoreplicationArgs>>? = null, identity: Output<RegistryIdentityArgs>? = null, location: Output<String>? = null, name: Output<String>? = null, networkRuleBypassOption: Output<String>? = null, networkRuleSet: Output<RegistryNetworkRuleSetArgs>? = null, publicNetworkAccessEnabled: Output<Boolean>? = null, quarantinePolicyEnabled: Output<Boolean>? = null, resourceGroupName: Output<String>? = null, retentionPolicyInDays: Output<Int>? = null, sku: Output<String>? = null, tags: Output<Map<String, String>>? = null, trustPolicyEnabled: Output<Boolean>? = null, zoneRedundancyEnabled: Output<Boolean>? = null)

Properties

Link copied to clipboard
val adminEnabled: Output<Boolean>? = null

Specifies whether the admin user is enabled. Defaults to false.

Link copied to clipboard
val anonymousPullEnabled: Output<Boolean>? = null

Whether allows anonymous (unauthenticated) pull access to this Container Registry? This is only supported on resources with the Standard or Premium SKU.

Link copied to clipboard
val dataEndpointEnabled: Output<Boolean>? = null

Whether to enable dedicated data endpoints for this Container Registry? This is only supported on resources with the Premium SKU.

Link copied to clipboard
val encryption: Output<RegistryEncryptionArgs>? = null

An encryption block as documented below.

Link copied to clipboard
val exportPolicyEnabled: Output<Boolean>? = null

Boolean value that indicates whether export policy is enabled. Defaults to true. In order to set it to false, make sure the public_network_access_enabled is also set to false.

Link copied to clipboard
val georeplications: Output<List<RegistryGeoreplicationArgs>>? = null

One or more georeplications blocks as documented below.

Link copied to clipboard
val identity: Output<RegistryIdentityArgs>? = null

An identity block as defined below.

Link copied to clipboard
val location: Output<String>? = null

Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.

Link copied to clipboard
val name: Output<String>? = null

Specifies the name of the Container Registry. Only Alphanumeric characters allowed. Changing this forces a new resource to be created.

Link copied to clipboard
val networkRuleBypassOption: Output<String>? = null

Whether to allow trusted Azure services to access a network restricted Container Registry? Possible values are None and AzureServices. Defaults to AzureServices.

Link copied to clipboard
val networkRuleSet: Output<RegistryNetworkRuleSetArgs>? = null

A network_rule_set block as documented below.

Link copied to clipboard
val publicNetworkAccessEnabled: Output<Boolean>? = null

Whether public network access is allowed for the container registry. Defaults to true.

Link copied to clipboard
val quarantinePolicyEnabled: Output<Boolean>? = null

Boolean value that indicates whether quarantine policy is enabled.

Link copied to clipboard
val resourceGroupName: Output<String>? = null

The name of the resource group in which to create the Container Registry. Changing this forces a new resource to be created.

Link copied to clipboard
val retentionPolicyInDays: Output<Int>? = null

The number of days to retain and untagged manifest after which it gets purged. Defaults to 7.

Link copied to clipboard
val sku: Output<String>? = null

The SKU name of the container registry. Possible values are Basic, Standard and Premium.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

A mapping of tags to assign to the resource.

Link copied to clipboard
val trustPolicyEnabled: Output<Boolean>? = null

Boolean value that indicated whether trust policy is enabled. Defaults to false.

Link copied to clipboard
val zoneRedundancyEnabled: Output<Boolean>? = null

Whether zone redundancy is enabled for this Container Registry? Changing this forces a new resource to be created. Defaults to false.

Functions

Link copied to clipboard
open override fun toJava(): RegistryArgs