def show_storage_account_usage(cmd, location):
scf = storage_client_factory(cmd.cli_ctx)
try:
client = scf.usages
except NotImplementedError:
client = scf.usage
return next((x for x in client.list_by_location(location) if x.name.value == 'StorageAccounts'), None) # pylint: disable=no-member
def create_storage_account(cmd, resource_group_name, account_name, sku=None, location=None, kind=None,
tags=None, custom_domain=None, encryption_services=None, access_tier=None, https_only=None,
bypass=None, default_action=None, assign_identity=False):
StorageAccountCreateParameters, Kind, Sku, CustomDomain, AccessTier, Identity, Encryption, NetworkRuleSet = \
cmd.get_models('StorageAccountCreateParameters', 'Kind', 'Sku', 'CustomDomain', 'AccessTier', 'Identity',
'Encryption', 'NetworkRuleSet')
scf = storage_client_factory(cmd.cli_ctx)
params = StorageAccountCreateParameters(sku=Sku(sku), kind=Kind(kind), location=location, tags=tags)
if custom_domain:
params.custom_domain = CustomDomain(custom_domain, None)
if encryption_services:
params.encryption = Encryption(services=encryption_services)
if access_tier:
params.access_tier = AccessTier(access_tier)
if assign_identity:
params.identity = Identity()
if https_only:
params.enable_https_traffic_only = https_only
if NetworkRuleSet and (bypass or default_action):
if bypass and not default_action:
raise CLIError('incorrect usage: --default-action ACTION [--bypass SERVICE ...]')
params.network_rule_set = NetworkRuleSet(bypass=bypass, default_action=default_action, ip_rules=None,
virtual_network_rules=None)
return scf.storage_accounts.create(resource_group_name, account_name, params)
def list_storage_accounts(cmd, resource_group_name=None):
scf = storage_client_factory(cmd.cli_ctx)
if resource_group_name:
accounts = scf.storage_accounts.list_by_resource_group(resource_group_name)
else:
accounts = scf.storage_accounts.list()
return list(accounts)
def show_storage_account_connection_string(cmd,
resource_group_name,
account_name,
protocol='https',
blob_endpoint=None,
file_endpoint=None,
queue_endpoint=None,
table_endpoint=None,
key_name='primary'):
scf = storage_client_factory(cmd.cli_ctx)
obj = scf.storage_accounts.list_keys(resource_group_name, account_name) # pylint: disable=no-member
try:
keys = [obj.keys[0].value, obj.keys[1].value] # pylint: disable=no-member
except AttributeError:
# Older API versions have a slightly different structure
keys = [obj.key1, obj.key2] # pylint: disable=no-member
endpoint_suffix = cmd.cli_ctx.cloud.suffixes.storage_endpoint
connection_string = 'DefaultEndpointsProtocol={};EndpointSuffix={};AccountName={};AccountKey={}'.format(
protocol, endpoint_suffix, account_name,
keys[0] if key_name == 'primary' else keys[1]) # pylint: disable=no-member
connection_string = '{}{}'.format(
connection_string,
';BlobEndpoint={}'.format(blob_endpoint) if blob_endpoint else '')
connection_string = '{}{}'.format(
connection_string,
';FileEndpoint={}'.format(file_endpoint) if file_endpoint else '')
connection_string = '{}{}'.format(
connection_string,
';QueueEndpoint={}'.format(queue_endpoint) if queue_endpoint else '')
connection_string = '{}{}'.format(
connection_string,
';TableEndpoint={}'.format(table_endpoint) if table_endpoint else '')
return {'connectionString': connection_string}
def show_storage_account_usage(cmd, location):
scf = storage_client_factory(cmd.cli_ctx)
try:
client = scf.usages
except NotImplementedError:
client = scf.usage
return next((x for x in client.list_by_location(location) if x.name.value == 'StorageAccounts'), None) # pylint: disable=no-member
def show_storage_account_connection_string(cmd, resource_group_name, account_name, protocol='https', blob_endpoint=None,
file_endpoint=None, queue_endpoint=None, table_endpoint=None,
key_name='primary'):
scf = storage_client_factory(cmd.cli_ctx)
obj = scf.storage_accounts.list_keys(resource_group_name, account_name) # pylint: disable=no-member
try:
keys = [obj.keys[0].value, obj.keys[1].value] # pylint: disable=no-member
except AttributeError:
# Older API versions have a slightly different structure
keys = [obj.key1, obj.key2] # pylint: disable=no-member
endpoint_suffix = cmd.cli_ctx.cloud.suffixes.storage_endpoint
connection_string = 'DefaultEndpointsProtocol={};EndpointSuffix={};AccountName={};AccountKey={}'.format(
protocol,
endpoint_suffix,
account_name,
keys[0] if key_name == 'primary' else keys[1]) # pylint: disable=no-member
connection_string = '{}{}'.format(connection_string,
';BlobEndpoint={}'.format(blob_endpoint) if blob_endpoint else '')
connection_string = '{}{}'.format(connection_string,
';FileEndpoint={}'.format(file_endpoint) if file_endpoint else '')
connection_string = '{}{}'.format(connection_string,
';QueueEndpoint={}'.format(queue_endpoint) if queue_endpoint else '')
connection_string = '{}{}'.format(connection_string,
';TableEndpoint={}'.format(table_endpoint) if table_endpoint else '')
return {'connectionString': connection_string}
def list_storage_accounts(cmd, resource_group_name=None):
scf = storage_client_factory(cmd.cli_ctx)
if resource_group_name:
accounts = scf.storage_accounts.list_by_resource_group(resource_group_name)
else:
accounts = scf.storage_accounts.list()
return list(accounts)
def create_storage_account(cmd, resource_group_name, account_name, sku=None, location=None, kind=None,
tags=None, custom_domain=None, encryption_services=None, access_tier=None, https_only=None,
bypass=None, default_action=None, assign_identity=False):
StorageAccountCreateParameters, Kind, Sku, CustomDomain, AccessTier, Identity, Encryption, NetworkRuleSet = \
cmd.get_models('StorageAccountCreateParameters', 'Kind', 'Sku', 'CustomDomain', 'AccessTier', 'Identity',
'Encryption', 'NetworkRuleSet')
scf = storage_client_factory(cmd.cli_ctx)
params = StorageAccountCreateParameters(sku=Sku(name=sku), kind=Kind(kind), location=location, tags=tags)
if custom_domain:
params.custom_domain = CustomDomain(name=custom_domain, use_sub_domain=None)
if encryption_services:
params.encryption = Encryption(services=encryption_services)
if access_tier:
params.access_tier = AccessTier(access_tier)
if assign_identity:
params.identity = Identity()
if https_only:
params.enable_https_traffic_only = https_only
# temporary fix to allow idempotent create when value is None. (sdk defaults with False)
params.is_hns_enabled = None
if NetworkRuleSet and (bypass or default_action):
if bypass and not default_action:
from knack.util import CLIError
raise CLIError('incorrect usage: --default-action ACTION [--bypass SERVICE ...]')
params.network_rule_set = NetworkRuleSet(bypass=bypass, default_action=default_action, ip_rules=None,
virtual_network_rules=None)
return scf.storage_accounts.create(resource_group_name, account_name, params)
def _query_account_rg(cli_ctx, account_name):
"""Query the storage account's resource group, which the mgmt sdk requires."""
scf = storage_client_factory(cli_ctx)
acc = next((x for x in scf.storage_accounts.list() if x.name == account_name), None)
if acc:
from msrestazure.tools import parse_resource_id
return parse_resource_id(acc.id)['resource_group'], scf
raise ValueError("Storage account '{}' not found.".format(account_name))
def create_storage_account(cmd,
resource_group_name,
account_name,
sku=None,
location=None,
kind=None,
tags=None,
custom_domain=None,
encryption_services=None,
access_tier=None,
https_only=None,
enable_files_aadds=None,
bypass=None,
default_action=None,
assign_identity=False):
StorageAccountCreateParameters, Kind, Sku, CustomDomain, AccessTier, Identity, Encryption, NetworkRuleSet = \
cmd.get_models('StorageAccountCreateParameters', 'Kind', 'Sku', 'CustomDomain', 'AccessTier', 'Identity',
'Encryption', 'NetworkRuleSet')
scf = storage_client_factory(cmd.cli_ctx)
logger.warning(
"The default kind for created storage account will change to 'StorageV2' from 'Storage' in future"
)
params = StorageAccountCreateParameters(sku=Sku(name=sku),
kind=Kind(kind),
location=location,
tags=tags)
if custom_domain:
params.custom_domain = CustomDomain(name=custom_domain,
use_sub_domain=None)
if encryption_services:
params.encryption = Encryption(services=encryption_services)
if access_tier:
params.access_tier = AccessTier(access_tier)
if assign_identity:
params.identity = Identity()
if https_only:
params.enable_https_traffic_only = https_only
if enable_files_aadds is not None:
AzureFilesIdentityBasedAuthentication = cmd.get_models(
'AzureFilesIdentityBasedAuthentication')
params.azure_files_identity_based_authentication = AzureFilesIdentityBasedAuthentication(
directory_service_options='AADDS' if enable_files_aadds else 'None'
)
if NetworkRuleSet and (bypass or default_action):
if bypass and not default_action:
from knack.util import CLIError
raise CLIError(
'incorrect usage: --default-action ACTION [--bypass SERVICE ...]'
)
params.network_rule_set = NetworkRuleSet(bypass=bypass,
default_action=default_action,
ip_rules=None,
virtual_network_rules=None)
return scf.storage_accounts.create(resource_group_name, account_name,
params)
def create_storage_account_with_account_type(cmd,
resource_group_name,
account_name,
account_type,
location=None,
tags=None):
StorageAccountCreateParameters, AccountType = cmd.get_models(
'StorageAccountCreateParameters', 'AccountType')
scf = storage_client_factory(cmd.cli_ctx)
params = StorageAccountCreateParameters(location,
AccountType(account_type), tags)
return scf.storage_accounts.create(resource_group_name, account_name,
params)
def create_storage_account(cmd, resource_group_name, account_name, sku=None, location=None, kind=None,
tags=None, custom_domain=None, encryption_services=None, access_tier=None, https_only=None,
enable_files_aadds=None, bypass=None, default_action=None, assign_identity=False,
enable_large_file_share=None, enable_files_adds=None, domain_name=None,
net_bios_domain_name=None, forest_name=None, domain_guid=None, domain_sid=None,
azure_storage_sid=None, enable_hierarchical_namespace=None,
encryption_key_type_for_table=None, encryption_key_type_for_queue=None,
routing_choice=None, publish_microsoft_endpoints=None, publish_internet_endpoints=None):
StorageAccountCreateParameters, Kind, Sku, CustomDomain, AccessTier, Identity, Encryption, NetworkRuleSet = \
cmd.get_models('StorageAccountCreateParameters', 'Kind', 'Sku', 'CustomDomain', 'AccessTier', 'Identity',
'Encryption', 'NetworkRuleSet')
scf = storage_client_factory(cmd.cli_ctx)
if kind is None:
logger.warning("The default kind for created storage account will change to 'StorageV2' from 'Storage' "
"in the future")
params = StorageAccountCreateParameters(sku=Sku(name=sku), kind=Kind(kind), location=location, tags=tags)
if custom_domain:
params.custom_domain = CustomDomain(name=custom_domain, use_sub_domain=None)
if encryption_services:
params.encryption = Encryption(services=encryption_services)
if access_tier:
params.access_tier = AccessTier(access_tier)
if assign_identity:
params.identity = Identity()
if https_only is not None:
params.enable_https_traffic_only = https_only
if enable_hierarchical_namespace is not None:
params.is_hns_enabled = enable_hierarchical_namespace
AzureFilesIdentityBasedAuthentication = cmd.get_models('AzureFilesIdentityBasedAuthentication')
if enable_files_aadds is not None:
params.azure_files_identity_based_authentication = AzureFilesIdentityBasedAuthentication(
directory_service_options='AADDS' if enable_files_aadds else 'None')
if enable_files_adds is not None:
from knack.util import CLIError
ActiveDirectoryProperties = cmd.get_models('ActiveDirectoryProperties')
if enable_files_adds: # enable AD
if not (domain_name and net_bios_domain_name and forest_name and domain_guid and domain_sid and
azure_storage_sid):
raise CLIError("To enable ActiveDirectoryDomainServicesForFile, user must specify all of: "
"--domain-name, --net-bios-domain-name, --forest-name, --domain-guid, --domain-sid and "
"--azure_storage_sid arguments in Azure Active Directory Properties Argument group.")
active_directory_properties = ActiveDirectoryProperties(domain_name=domain_name,
net_bios_domain_name=net_bios_domain_name,
forest_name=forest_name, domain_guid=domain_guid,
domain_sid=domain_sid,
azure_storage_sid=azure_storage_sid)
# TODO: Enabling AD will automatically disable AADDS. Maybe we should throw error message
params.azure_files_identity_based_authentication = AzureFilesIdentityBasedAuthentication(
directory_service_options='AD',
active_directory_properties=active_directory_properties)
else: # disable AD
if domain_name or net_bios_domain_name or forest_name or domain_guid or domain_sid or azure_storage_sid: # pylint: disable=too-many-boolean-expressions
raise CLIError("To disable ActiveDirectoryDomainServicesForFile, user can't specify any of: "
"--domain-name, --net-bios-domain-name, --forest-name, --domain-guid, --domain-sid and "
"--azure_storage_sid arguments in Azure Active Directory Properties Argument group.")
params.azure_files_identity_based_authentication = AzureFilesIdentityBasedAuthentication(
directory_service_options='None')
if enable_large_file_share:
LargeFileSharesState = cmd.get_models('LargeFileSharesState')
params.large_file_shares_state = LargeFileSharesState("Enabled")
if NetworkRuleSet and (bypass or default_action):
if bypass and not default_action:
from knack.util import CLIError
raise CLIError('incorrect usage: --default-action ACTION [--bypass SERVICE ...]')
params.network_rule_set = NetworkRuleSet(bypass=bypass, default_action=default_action, ip_rules=None,
virtual_network_rules=None)
if encryption_key_type_for_table is not None or encryption_key_type_for_queue is not None:
EncryptionServices = cmd.get_models('EncryptionServices')
EncryptionService = cmd.get_models('EncryptionService')
params.encryption = Encryption()
params.encryption.services = EncryptionServices()
if encryption_key_type_for_table is not None:
table_encryption_service = EncryptionService(enabled=True, key_type=encryption_key_type_for_table)
params.encryption.services.table = table_encryption_service
if encryption_key_type_for_queue is not None:
queue_encryption_service = EncryptionService(enabled=True, key_type=encryption_key_type_for_queue)
params.encryption.services.queue = queue_encryption_service
if any([routing_choice, publish_microsoft_endpoints, publish_internet_endpoints]):
RoutingPreference = cmd.get_models('RoutingPreference')
params.routing_preference = RoutingPreference(
routing_choice=routing_choice,
publish_microsoft_endpoints=str2bool(publish_microsoft_endpoints),
publish_internet_endpoints=str2bool(publish_internet_endpoints)
)
return scf.storage_accounts.create(resource_group_name, account_name, params)
def get_storage_account_properties(cli_ctx, account_id):
scf = storage_client_factory(cli_ctx)
from msrestazure.tools import parse_resource_id
result = parse_resource_id(account_id)
return scf.storage_accounts.get_properties(result['resource_group'], result['name'])
def show_storage_account_usage_no_location(cmd):
scf = storage_client_factory(cmd.cli_ctx)
return next((x for x in scf.usage.list() if x.name.value == 'StorageAccounts'), None) # pylint: disable=no-member
def show_storage_account_usage_no_location(cmd):
scf = storage_client_factory(cmd.cli_ctx)
return next((x for x in scf.usage.list() if x.name.value == 'StorageAccounts'), None) # pylint: disable=no-member
