def get_or_create_workspace(subscription, resource_group, workspace_name,
location, **kwargs):
print("Info: {}, {}, {}, {}".format(subscription, resource_group,
workspace_name, location))
try:
workspace = Workspace.get(name=workspace_name,
subscription_id=subscription,
resource_group=resource_group)
cprint('Using existing workspace "{}"'.format(workspace_name), "green")
except WorkspaceException:
cprint(
'Creating new workspace "{}":'.format(workspace_name),
"green",
attrs=["bold"],
)
workspace = Workspace.create(name=workspace_name,
subscription_id=subscription,
resource_group=resource_group,
location=location,
**kwargs)
cprint("Using Workspace name={}, resource_group={}, subscription_id={}".
format(workspace.name, workspace.resource_group,
workspace.subscription_id))
return workspace
def main(name: str, subscription_id: str, resource_group: str, location: str):
"""Create Workspace on Azure ML Service
- https://docs.microsoft.com/pt-br/azure/machine-learning
/how-to-manage-workspace?tab=python&tabs=python#create-multi-tenant
"""
print(location)
click.secho("[ML SERVICE] - Creating Workspace...", fg="green")
cli_auth = AzureCliAuthentication()
ws = Workspace.create(
name=name,
subscription_id=subscription_id,
resource_group=resource_group,
create_resource_group=True,
location=location,
auth=cli_auth,
)
ws.write_config(".azureml")
print(
"\tWorkspace name: " + ws.name,
"Azure region: " + ws.location,
"Subscription id: " + ws.subscription_id,
"Resource group: " + ws.resource_group,
sep="\n\t",
)
def create_workspace(subscription_id, resource_group, workspace_name, region):
if subscription_id is None:
subscription_id = input("enter your subscription id : ")
else:
print("working on subscription :", subscription_id)
if resource_group is None:
resource_group = input("enter your resource groupe id : ")
else:
print("working on resource group :", resource_group)
if workspace_name is None:
workspace_name = input("enter your workspace name : ")
else:
print("working on workspace :", workspace_name)
from azureml.core import Workspace
try:
ws = Workspace(subscription_id=subscription_id,
resource_group=resource_group,
workspace_name=workspace_name)
# write the details of the workspace to a configuration file to the notebook library
ws.write_config()
print(
"Workspace configuration succeeded. Skip the workspace creation steps below"
)
except:
ws = Workspace.create(name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
location=region,
create_resource_group=True,
exist_ok=True)
ws.get_details()
# write the details of the workspace to a configuration file to the notebook library
ws.write_config()
return ws
def main(argv):
try:
opts, args = getopt.getopt(argv,"hs:rg:wn:wr:",["subscription_id=","resource_group=","workspace_name=", "workspace_region="])
except getopt.GetoptError:
print 'aml_creation.py -s <subscription_id> -rg <resource_group> -wn <workspace_name> -wr <workspace_region>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'aml_creation.py -s <subscription_id> -rg <resource_group> -wn <workspace_name> -wr <workspace_region>'
sys.exit()
elif opt in ("-s", "--subscription_id"):
subscription_id = arg
elif opt in ("-rg", "--resource_group"):
resource_group = arg
elif opt in ("-wn", "--workspace_name"):
workspace_name = arg
elif opt in ("-wr", "--workspace_region"):
workspace_region = arg
env_path = find_dotenv()
if env_path == "":
Path(".env").touch()
env_path = find_dotenv()
ws = Workspace.create(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
location=workspace_region,
create_resource_group=True,
auth=get_auth(env_path),
exist_ok=True,
)
def get_or_create_workspace(
subscription_id: str,
resource_group: str,
workspace_name: str,
workspace_region: str,
) -> Workspace:
try:
ws = Workspace(
subscription_id=subscription_id,
resource_group=resource_group,
workspace_name=workspace_name,
)
# write the details of the workspace to a configuration file to the notebook library
ws.write_config()
logger.info(
"Workspace configuration succeeded. Skip the workspace creation steps below"
)
except ProjectSystemException as e:
logger.exception(e)
# Create the workspace using the specified parameters
ws = Workspace.create(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
location=workspace_region,
create_resource_group=True,
sku="basic",
exist_ok=True,
)
ws.get_details()
# write the details of the workspace to a configuration file to the notebook library
ws.write_config()
return ws
def get_workspace(compute_name=None, compute_config=None):
if TENANT_ID is None or \
SERVICE_PRINCIPAL_ID is None or \
SERVICE_PRINCIPAL_PASSWORD is None or \
SUBSCRIPTION_ID is None or \
RESOURCE_GROUP_NAME is None or \
WORKSPACE_NAME is None or \
WORKSPACE_LOCATION is None:
print("One of the required environment variables is not set. "
"Running locally instead.")
return None
logger.info("Logging in as service principal.")
auth = ServicePrincipalAuthentication(TENANT_ID,
SERVICE_PRINCIPAL_ID,
SERVICE_PRINCIPAL_PASSWORD)
logger.info("Successfully logged in as service principal.")
logger.info("Ensuring resource group {} exists.".format(RESOURCE_GROUP_NAME))
resource_management_client = resource_client_factory(auth, SUBSCRIPTION_ID)
resource_group_properties = ResourceGroup(location=WORKSPACE_LOCATION)
resource_management_client.resource_groups.create_or_update(WORKSPACE_NAME,
resource_group_properties)
logger.info("Ensured resource group {} exists.".format(RESOURCE_GROUP_NAME))
logger.info("Ensuring workspace {} exists.".format(WORKSPACE_NAME))
workspace = Workspace.create(name=WORKSPACE_NAME, auth=auth, subscription_id=SUBSCRIPTION_ID,
resource_group=RESOURCE_GROUP_NAME, location=WORKSPACE_LOCATION,
create_resource_group=False, exist_ok=True)
logger.info("Ensured workspace {} exists.".format(WORKSPACE_NAME))
logger.info("Ensuring compute exists.")
get_or_create_compute_cluster(workspace, compute_name, compute_config)
logger.info("Ensured compute exists.")
return workspace
def get_or_create_workspace(subscription_id: str, resource_group: str,
workspace_name: str,
workspace_region: str) -> Workspace:
"""
Returns workspace if one exists already with the name
otherwise creates a new one.
Args
subscription_id: Azure subscription id
resource_group: Azure resource group to create workspace and related resources
workspace_name: name of azure ml workspace
workspace_region: region for workspace
"""
try:
# get existing azure ml workspace
ws = Workspace.get(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
auth=get_auth(),
)
except:
# this call might take a minute or two.
print("Creating new workspace")
ws = Workspace.create(name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
create_resource_group=True,
location=workspace_region,
auth=get_auth())
return ws
def setUpAzureMLWorkspace(subscription_id, resource_group, location):
ws = Workspace.create(
name='myworkspace',
subscription_id=subscription_id,
resource_group=resource_group,
location=location # Or other supported Azure region
)
ws.write_config("azure_ml.cfg")
def create_workspace(azureml_path: str = Path("..", "..", ".azureml")):
ws = Workspace.create(name='TravelInsurance',
subscription_id=os.environ["SUBSCRIPTION_ID"],
resource_group=os.environ["RESOURCE_GROUP"],
create_resource_group=True,
location=os.environ["SERVER_LOCATION"])
# write out the workspace details to a configuration file: .azureml/config.json
ws.write_config(path=azureml_path)
def get_or_create_workspace(
workspace_name: str,
subscription_id: str,
resource_group: str,
workspace_region: str,
auth: Union[
InteractiveLoginAuthentication,
ServicePrincipalAuthentication] = InteractiveLoginAuthentication(),
log=True,
) -> Workspace:
"""
Create a new Azure Machine Learning workspace. If the workspace already exists, the existing workspace will be
returned. Also create a CONFIG file to quickly reload the workspace.
This uses the :class:`azureml.core.authentication.InteractiveLoginAuthentication` or will default to use the
:class:`azureml.core.authentication.AzureCliAuthentication` for logging into Azure.
Run az login from the CLI in the project directory to avoid authentication when running the program.
:param workspace_name: Name of Azure Machine Learning Workspace to get or create within the Azure Subscription
:type workspace_name: str
:param subscription_id: Azure subscription id
Azure Subscription ID
:type subscription_id: str
:param resource_group: Azure Resource Group to get or create the workspace within. If the resource group does not
exist it will be created.
:type resource_group: str
:param workspace_region: The Azure region to deploy the workspace.
:type workspace_region: str
:param auth: Derived classes provide different means to authenticate and acquire a token based on their targeted
use case.
For examples of authentication, see https://aka.ms/aml-notebook-auth.
:type auth: azureml.core.authentication.AbstractAuthentication
:param log: enable print output
:return: Returns a :class:`azureml.core.Workspace` object, a pointer to Azure Machine Learning Workspace
Learning Workspace
:rtype: azureml.core.Workspace
"""
if log:
print("AML SDK Version:", azureml.core.VERSION)
workspace = Workspace.create(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
location=workspace_region,
auth=auth,
exist_ok=True,
)
workspace.write_config()
if log:
ws_json = json.dumps(workspace.get_details(), indent=2)
print(ws_json)
return workspace
def main(name, resource_group, location, subscription_id):
ws = Workspace.create(name=name,
resource_group=resource_group,
subscription_id=subscription_id,
location=location,
exist_ok=True,
show_output=True)
ws.write_config()
def getOrCreateWorkspace(subscription_id, resource_group, workspace_name,
workspace_region):
# By using the exist_ok param, if the workspace already exists we get a reference to the existing workspace instead of an error
ws = Workspace.create(name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
location=workspace_region,
exist_ok=True)
return ws
def get_workspace(
name: str,
resource_group: str,
subscription_id: str,
tenant_id: str,
app_id: str,
app_secret: str,
region: str,
create_if_not_exist=False,
):
"""
Parameters:
name (str): name of the workspace
resource_group (str): resource group name
subscription_id (str): subscription id
tenant_id (str): tenant id (aad id)
app_id (str): service principal id
app_secret (str): service principal password
region (str): location of the workspace
create_if_not_exist (bool): Default value is False
Returns:
Workspace: a reference to a workspace
"""
service_principal = ServicePrincipalAuthentication(
tenant_id=tenant_id,
service_principal_id=app_id,
service_principal_password=app_secret,
)
try:
aml_workspace = Workspace.get(
name=name,
subscription_id=subscription_id,
resource_group=resource_group,
auth=service_principal,
)
except WorkspaceException as exp_var:
log.error("Error while retrieving Workspace...: %s", exp_var)
if create_if_not_exist:
log.info("Creating AzureML Workspace: %s", name)
aml_workspace = Workspace.create(
name=name,
subscription_id=subscription_id,
resource_group=resource_group,
create_resource_group=True,
location=region,
auth=service_principal,
)
log.info("Workspace %s created.", aml_workspace.name)
else:
sys.exit(-1)
return aml_workspace
def create_workspace(self, workspace_name):
# Create the workspace using the specified parameters
self.ws = Workspace.create(name=workspace_name,
subscription_id=self.subscription_id,
resource_group=self.rg_name,
location=self.location,
create_resource_group=True,
exist_ok=True)
self.ws.get_details()
return self.ws
def create_workspace(subscription_id,ws_name='myworkspace',create_resource_group=True,resource_group='myresourcegroup',location='eastus2'):
ws = Workspace.create(
name=ws_name,
subscription_id=subscription_id,
resource_group=resource_group,
create_resource_group=create_resource_group,
location=location
)
print('Created Workspace')
ws.write_config()
print("Saved config file")
def get_or_create_workspace(
config_path="./.azureml",
subscription_id=None,
resource_group=None,
workspace_name=None,
workspace_region=None,
):
"""
Method to get or create workspace.
Args:
config_path: optional directory to look for / store config.json file (defaults to current
directory)
subscription_id: Azure subscription id
resource_group: Azure resource group to create workspace and related resources
workspace_name: name of azure ml workspace
workspace_region: region for workspace
Returns:
obj: AzureML workspace if one exists already with the name otherwise creates a new one.
"""
config_file_path = "."
if config_path is not None:
config_dir, config_file_name = os.path.split(config_path)
if config_file_name != "config.json":
config_file_path = os.path.join(config_path, "config.json")
try:
# get existing azure ml workspace
if os.path.isfile(config_file_path):
ws = Workspace.from_config(config_file_path, auth=get_auth())
else:
ws = Workspace.get(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
auth=get_auth(),
)
except ProjectSystemException:
# this call might take a minute or two.
print("Creating new workspace")
ws = Workspace.create(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
create_resource_group=True,
location=workspace_region,
auth=get_auth(),
)
ws.write_config(path=config_path)
return ws
def azureml_workspace(auth_type='interactive'):
if auth_type == 'interactive':
auth = interactive_auth()
elif auth_type == 'service_princpal':
auth = service_principal_auth()
ws = Workspace.create(name=workspace_name,
resource_group=resource_group,
subscription_id=subscription_id,
exist_ok=True,
auth=auth)
return ws
def getWorkspace(authentication, subscription_id, resource_group,
workspace_name, workspace_region):
'''
Obtains an existing workspace, or creates a new one. If a workspace exists in the subscription
in the same resource group, with the same name it is returned, otherwise, a new one is created.
PARAMS:
authentication : azureml.core.authentication : User Authentication with rights to sub
subscription_id : String : Azure Subscription ID
resource_group : String : Azure Resource Group Name
workspace_name : String : AMLS workspace name
workspace_region : String : Azure Region
RETURNS:
azureml.core.Workspace
'''
return_workspace = None
useExistingWorkspace = False
workspaces = None
'''
If resource group doesn't exist, this will throw a ProjectSystemException
'''
try:
workspaces = Workspace.list(subscription_id, authentication,
resource_group)
except Exception as ex:
workspaces = None
'''
See if it already exists
'''
if workspaces:
for ws in workspaces.keys():
if ws == workspace_name:
useExistingWorkspace = True
'''
Return existing or create new
'''
if useExistingWorkspace:
print("Loading existing workspace ....", workspace_name)
return_workspace = Workspace.get(name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group)
else:
# Create one
print("Creating new workspace ....", workspace_name)
return_workspace = Workspace.create(name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
create_resource_group=True,
location=workspace_region)
return return_workspace # program_context.workspace.get_details()
def create_workspace(workspace_name,
subscription_id,
resource_group,
location='westeurope',
create_resource_group=False):
ws = Workspace.create(name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
create_resource_group=create_resource_group,
location=location)
ws.write_config()
def main(argv):
try:
opts, args = getopt.getopt(argv,"hs:rg:wn:wr:dsn:cn:an:ak:drg:",
["subscription_id=","resource_group=","workspace_name=", "workspace_region=","blob_datastore_name=","container_name=","account_name=","account_key=","datastore_rg="])
except getopt.GetoptError:
print 'aml_creation.py -s <subscription_id> -rg <resource_group> -wn <workspace_name> -wr <workspace_region>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'aml_creation.py -s <subscription_id> -rg <resource_group> -wn <workspace_name> -wr <workspace_region>'
sys.exit()
elif opt in ("-s", "--subscription_id"):
subscription_id = arg
elif opt in ("-rg", "--resource_group"):
resource_group = arg
elif opt in ("-wn", "--workspace_name"):
workspace_name = arg
elif opt in ("-wr", "--workspace_region"):
workspace_region = arg
elif opt in ("-dsn", "--blob_datastore_name"):
workspace_region = arg
elif opt in ("-cn", "--container_name"):
workspace_region = arg
elif opt in ("-an", "--account_name"):
workspace_region = arg
elif opt in ("-ak", "--account_key"):
workspace_region = arg
elif opt in ("-drg", "--datastore_rg"):
workspace_region = arg
env_path = find_dotenv()
if env_path == "":
Path(".env").touch()
env_path = find_dotenv()
ws = Workspace.create(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
location=workspace_region,
create_resource_group=True,
auth=get_auth(env_path),
exist_ok=True,
)
blob_datastore = Datastore.register_azure_blob_container(workspace=ws,
datastore_name=blob_datastore_name,
container_name=container_name,
account_name=account_name,
account_key=account_key,
resource_group=datastore_rg)
def load_workspace():
load_dotenv()
try:
ws = Workspace.get(subscription_id=os.getenv("subscription_id"),
resource_group=os.getenv("resource_group"),
name=os.getenv("workspace_name"))
except:
ws = Workspace.create(subscription_id=os.getenv("subscription_id"),
resource_group=os.getenv("resource_group"),
name=os.getenv("workspace_name"),
location=os.getenv("location"))
return ws
def create_ws(subscription_id, name):
'''Creates an azure workspace'''
subscription_id = subscription_id
# resource_group = 'birdsong_classification'
# workspace_name = 'birdsong_classification'
workspace = Workspace.create(name=name,
subscription_id=subscription_id,
resource_group=name,
create_resource_group=True,
location='northcentralus')
workspace.write_config(path='.azureml')
def _get_workspace(self):
self.log.info(f"Setting workspace {self.workspace_name}.")
self._add_event(f"Setting workspace {self.workspace_name}", 1)
self.workspace = Workspace.create(
name=self.workspace_name,
subscription_id=self.subscription_id,
resource_group=self.resource_group_name,
create_resource_group=False,
location=self.location,
sku='enterprise',
show_output=False,
exist_ok=True,
auth=self.sp_auth)
self.log.info(f"Using workspace: {self.workspace_name}.")
self._add_event(f"Using workspace: {self.workspace_name}.", 10)
def setup_workspace(workspace_name, subscription_id, resource_group, cli_auth,
location):
"""
This sets up an Azure Workspace.
An existing Azure Workspace is used or a new one is created if needed for
the pytest run.
Args:
workspace_name (str): Centralized location on Azure to work
with all the artifacts used by AzureML
service
subscription_id (str): the Azure subscription id
resource_group (str): Azure Resource Groups are logical collections of
assets associated with a project. Resource groups
make it easy to track or delete all resources
associated with a project by tracking or deleting
the Resource group.
cli_auth Azure authentication
location (str): workspace reference
Returns:
ws: workspace reference
"""
logger.debug("setup: workspace_name is {}".format(workspace_name))
logger.debug("setup: resource_group is {}".format(resource_group))
logger.debug("setup: subid is {}".format(subscription_id))
logger.debug("setup: location is {}".format(location))
try:
# use existing workspace if there is one
ws = Workspace.get(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
auth=cli_auth,
)
except WorkspaceException:
# this call might take a minute or two.
logger.debug("Creating new workspace")
ws = Workspace.create(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
# create_resource_group=True,
location=location,
auth=cli_auth,
)
return ws
def create_workspace(self,
workspace_name,
location,
resource_group,
subscription_id,
container_registry=None,
app_insights=None):
return Workspace.create(
workspace_name,
auth=self.auth,
subscription_id=subscription_id,
location=location,
resource_group=resource_group,
create_resource_group=True,
app_insights=app_insights,
container_registry=container_registry)
def setup(num):
workspace_name = '%s-%s-%02d' % (workspace_prefix, location, num)
try:
ws = Workspace.get(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group)
print('Found existing workspace %s' % workspace_name)
except WorkspaceException:
print('Creating new workspace %s...' % workspace_name)
ws = Workspace.create(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
location=location)
try:
compute_target = AmlCompute(ws, compute_name)
print('Found existing compute %s' % compute_name)
compute_target.update(min_nodes=min_nodes, max_nodes=max_nodes)
except ComputeTargetException:
print('Creating new compute target %s...' % compute_name)
compute_config = AmlCompute.provisioning_configuration(vm_size=vm_size, min_nodes=min_nodes, max_nodes=max_nodes)
compute_target = ComputeTarget.create(ws, compute_name, compute_config)
compute_target.wait_for_completion(show_output=True, timeout_in_minutes=20)
ds = ws.get_default_datastore()
ds.upload("testdata")
dataset_name = 'sample_dataset'
if dataset_name not in ws.datasets:
data = Dataset.File.from_files(path=[(ds, 'testdata.txt')])
data.register(
workspace = ws,
name = dataset_name,
description = 'Sample data for load test')
print('Dataset successfully registered')
else:
print('Dataset already exists')
def create(self, name):
name = self._get_name(name)
region = self.ctx.config.get('cluster/region', 'eastus2')
resource_group = self.ctx.config.get(
'resource_group', name+'-resources')
self.ctx.log('Creating %s' % name)
self.ws = Workspace.create(
name=name,
subscription_id=self.credentials.subscription_id,
resource_group=resource_group,
create_resource_group=True,
location=region,
auth=self.credentials.get_serviceprincipal_auth())
self._select(name)
self.ctx.log('%s created' % name)
return {'created': name}
def main():
"""
Create workspace
"""
config = json.load(open("config/azureml.json", "r"))
work_space = Workspace.create(
name="mltibame", # provide a name for your workspace
subscription_id=config[
"subscription_id"], # provide your subscription ID
resource_group="Tibame", # provide a resource group name
create_resource_group=True,
location=
"eastus2", # For example: 'westeurope', 'eastus2', 'westus2' or 'southeastasia'.
)
# write out the workspace details to a configuration file: .azureml/config.json
work_space.write_config(path=".azureml")
def create(self, name):
name = self._get_name(name)
subscription_id = self.ctx.config.get('subscription_id', None)
if subscription_id is None:
raise AzureException('Please provide Azure subscription id...')
region = self.ctx.config.get('cluster/region', 'eastus2')
resource_group = self.ctx.config.get('resource_group',
name + '-resources')
self.ctx.log('Creating %s' % name)
self.ws = Workspace.create(name=name,
subscription_id=subscription_id,
resource_group=resource_group,
create_resource_group=True,
location=region,
auth=self._get_ws_auth())
self._select(name)
self.ctx.log('%s created' % name)
return {'created': name}
def get_workspace(workspace_location, workspace_name, resource_group,
subscription_id):
svc_pr = ServicePrincipalAuthentication(
tenant_id=dbutils.secrets.get(scope="azure-key-vault",
key="tenant-id"),
service_principal_id=dbutils.secrets.get(scope="azure-key-vault",
key="client-id"),
service_principal_password=dbutils.secrets.get(scope="azure-key-vault",
key="client-secret"))
workspace = Workspace.create(name=workspace_name,
location=workspace_location,
resource_group=resource_group,
subscription_id=subscription_id,
auth=svc_pr,
exist_ok=True)
print('Workspace: {} disponibilizada com sucesso'.format(workspace_name))
return workspace
