def get_workspace(self, workspace_name):
"""
Authenticates and returns the AzureML workspace handle
:param workspace_name: The workspace's name
:return The workspace handle. None on failure
"""
if not self.valid_config:
print("Please configure your Service Principal before trying to access the workspace")
print("\nVisit this URL for further details about setting up a Service Principal in your own subscription:")
print("https://docs.microsoft.com/en-us/azure/machine-learning/how-to-setup-authentication")
return None
# Authenticate via principal's credentials
config_data = self.config_data
svc_pr = ServicePrincipalAuthentication(
tenant_id=config_data['tenantId'],
service_principal_id=config_data['clientId'],
service_principal_password=config_data['clientSecret'])
workspaces = [key for key in Workspace.list(config_data['subscriptionId'], auth=svc_pr).keys()]
if workspace_name not in workspaces:
print(f"Workspace {workspace_name} not found in workspace list. Please create the workspace or adjust the scripts accordingly.")
print("\nFollowing workspaces could be found:")
for workspace in workspaces:
print(f"- {workspace}")
return None
if self.workspace==None:
self.workspace = Workspace.get(name=workspace_name, auth=svc_pr, resource_group=config_data['resourceGroup'], subscription_id=config_data['subscriptionId'])
return self.workspace
def __init__(self, spn_credentials, subscription_id, workspace_name,
resource_group):
auth = ServicePrincipalAuthentication(**spn_credentials)
self.workspace = Workspace(workspace_name=workspace_name,
auth=auth,
subscription_id=subscription_id,
resource_group=resource_group)
def init():
global g_tf_sess
svc_pr_password = "******"
svc_pr = ServicePrincipalAuthentication(
tenant_id="72f988bf-86f1-41af-91ab-2d7cd011db47",
service_principal_id="8a3ddafe-6dd6-48af-867e-d745232a1833",
service_principal_password="******")
ws = Workspace(
subscription_id="c46a9435-c957-4e6c-a0f4-b9a597984773",
resource_group="mlops",
workspace_name="gputraining",
auth=svc_pr
)
model_root = os.getenv('AZUREML_MODEL_DIR')
# Pull down the model from the workspace
model_path = Model.get_model_path("tf-dnn-mnist")
tf_model_folder = 'model'
# Create a model folder in the current directory
os.makedirs('./outputs', exist_ok=True)
os.makedirs('./outputs/model', exist_ok=True)
# Construct a graph to execute
tf.reset_default_graph()
saver = tf.train.import_meta_graph(os.path.join(model_path, 'tf-dnn-mnist.meta'))
g_tf_sess = tf.Session()
#saver.restore(g_tf_sess, os.path.join(model_path, tf_model_folder, 'tf-dnn-mnist.model'))
saver.restore(g_tf_sess, os.path.join(model_path, 'tf-dnn-mnist'))
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 authenticate():
print(f'TENANT_ID : {secret.TENANT_ID}')
svc_pr = ServicePrincipalAuthentication(
tenant_id=secret.TENANT_ID,
service_principal_id=secret.SERVICE_PRINCIPAL_APP_ID,
service_principal_password=secret.SERVICE_PRINCIPAL_SECRET)
return svc_pr
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.workspace = None
self.compute_instance = None
self._application_urls = None
self.redirect_server = None
self.subscription_id = os.environ['SUBSCRIPTION_ID']
self.location = os.environ['LOCATION']
self.tenant_id = os.environ["AAD_TENANT_ID"]
self.client_id = os.environ["AAD_CLIENT_ID"]
self.client_secret = os.environ["AAD_CLIENT_SECRET"]
self.cred = ClientSecretCredential(tenant_id=self.tenant_id,
client_id=self.client_id,
client_secret=self.client_secret)
self.sp_cred = ServicePrincipalCredentials(tenant=self.tenant_id,
client_id=self.client_id,
secret=self.client_secret)
self.sp_auth = ServicePrincipalAuthentication(
tenant_id=self.tenant_id,
service_principal_id=self.client_id,
service_principal_password=self.client_secret)
self.res_mgmt_client = ResourceManagementClient(
self.sp_cred, self.subscription_id)
self.compute_mgmt_client = ComputeManagementClient(
self.cred, self.subscription_id)
self.available_vm_sizes = self._available_vm_sizes()
def get_workspace():
import os
import json
from azureml.core.authentication import ServicePrincipalAuthentication
from azureml.core import Workspace
base_dir = "."
config_json = os.path.join(base_dir, "config.json")
with open(config_json, "r") as f:
config = json.load(f)
try:
svc_pr = ServicePrincipalAuthentication(
tenant_id=config["tenant_id"],
service_principal_id=config["service_principal_id"],
service_principal_password=config["service_principal_password"],
)
except KeyError:
print("Getting Service Principal Authentication from Azure Devops.")
svc_pr = None
pass
ws = Workspace.from_config(path=config_json, auth=svc_pr)
return ws
def cancel_running_and_queued_jobs() -> None:
environ = os.environ
print("Authenticating")
auth = ServicePrincipalAuthentication(
tenant_id='72f988bf-86f1-41af-91ab-2d7cd011db47',
service_principal_id=environ["APPLICATION_ID"],
service_principal_password=environ["APPLICATION_KEY"])
print("Getting AML workspace")
workspace = Workspace.get(name="InnerEye-DeepLearning",
auth=auth,
subscription_id=environ["SUBSCRIPTION_ID"],
resource_group="InnerEye-DeepLearning")
branch = environ["BRANCH"]
print(f"Branch: {branch}")
if not branch.startswith("refs/pull/"):
print("This branch is not a PR branch, hence not cancelling anything.")
exit(0)
experiment_name = branch.replace("/", "_")
print(f"Experiment: {experiment_name}")
experiment = Experiment(workspace, name=experiment_name)
print(f"Retrieved experiment {experiment.name}")
for run in experiment.get_runs(include_children=True, properties={}):
assert isinstance(run, Run)
status_suffix = f"'{run.status}' run {run.id} ({run.display_name})"
if run.status in (RunStatus.COMPLETED, RunStatus.FAILED,
RunStatus.FINALIZING, RunStatus.CANCELED,
RunStatus.CANCEL_REQUESTED):
print(f"Skipping {status_suffix}")
else:
print(f"Cancelling {status_suffix}")
run.cancel()
def retrieve_workspace() -> Workspace:
ws = None
try:
run = Run.get_context()
if not isinstance(run, _OfflineRun):
ws = run.experiment.workspace
return ws
except Exception as e:
print('Workspace from run not found', e)
try:
ws = Workspace.from_config()
return ws
except Exception as e:
print('Workspace config not found in local folder', e)
try:
sp = ServicePrincipalAuthentication(
tenant_id=os.environ['AML_TENANT_ID'],
service_principal_id=os.environ['AML_PRINCIPAL_ID'],
service_principal_password=os.environ['AML_PRINCIPAL_PASS'])
ws = Workspace.get(name="ml-example",
auth=sp,
subscription_id="your-sub-id")
except Exception as e:
print('Workspace config not found in project', e)
return ws
def retrieve_workspace() -> Workspace:
ws = None
try:
ws = Workspace.from_config()
return ws
except Exception as e:
print('Workspace not found in local repo.')
print('Trying Service Principal')
try:
sp = ServicePrincipalAuthentication(
tenant_id=os.environ['AML_TENANT_ID'],
service_principal_id=os.environ['AML_PRINCIPAL_ID'],
service_principal_password=os.environ['AML_PRINCIPAL_PASS'])
ws = Workspace.get(name=os.environ['AML_WORKSPACE_NAME'],
auth=sp,
subscription_id=os.environ['SUBSCRIPTION_ID'])
return ws
except Exception as e:
print('Connection via SP failed:', e)
if not ws:
print('Error - Workspace not found')
print('Error - Shuting everything down.')
sys.exit(-1)
def main():
load_dotenv()
TENANT_ID = os.environ.get('TENANT_ID')
APP_ID = os.environ.get('SP_APP_ID')
APP_SECRET = os.environ.get('SP_APP_SECRET')
WORKSPACE_NAME = os.environ.get("BASE_NAME") + "-aml"
SUBSCRIPTION_ID = os.environ.get('SUBSCRIPTION_ID')
RESOURCE_GROUP = os.environ.get("RESOURCE_GROUP_NAME")
EPIS_DATASTORE = os.environ.get("EPIS_DATASTORE")
ANNO_PATH_TRAIN = os.environ.get("ANNO_PATH_TRAIN")
ANNO_PATH_TEST = os.environ.get("ANNO_PATH_TEST")
EPIS_CONTAINER = os.environ.get("EPIS_CONTAINER")
SP_AUTH = ServicePrincipalAuthentication(
tenant_id=TENANT_ID,
service_principal_id=APP_ID,
service_principal_password=APP_SECRET)
WORKSPACE = Workspace.get(WORKSPACE_NAME, SP_AUTH, SUBSCRIPTION_ID,
RESOURCE_GROUP)
try:
convert_voc_annotation(WORKSPACE, EPIS_DATASTORE, "trainval",
ANNO_PATH_TRAIN, EPIS_CONTAINER)
convert_voc_annotation(WORKSPACE, EPIS_DATASTORE, "test",
ANNO_PATH_TEST, EPIS_CONTAINER)
except Exception as caught_error:
print("Error while download datastore: " + str(caught_error))
def shutdownComputeInstances():
#Get service principal details from app settings
subscriptionID = os.environ["subscriptionID"]
tenantID = os.environ["tenantID"]
clientID = os.environ["clientID"]
spSecret = os.environ["secret"]
resourceGroupName = os.environ["resourceGroupName"]
amlWorkspaceName = os.environ["amlWorkspaceName"]
#logging.info(subscriptionID, tenantID, clientID, spSecret)
#Authenticate to AML workspace with service principal
auth = ServicePrincipalAuthentication(tenant_id=tenantID,
service_principal_id=clientID,
service_principal_password=spSecret)
ws = Workspace(subscription_id=subscriptionID,
resource_group=resourceGroupName,
workspace_name=amlWorkspaceName,
auth=auth)
#Loop through workspace compute, stop all compute instances
computeList = ComputeTarget.list(ws)
for compute in computeList:
if compute.type == 'ComputeInstance':
logging.info("stop compute instance")
compute.stop()
def trigger_training_job(compute_name, script_folder):
# Define Vars < Change the vars>
tenant_id = "<Enter Your Tenant Id>"
app_id = "<Application Id of the SPN you Create>"
app_key = "<Key for the SPN>"
workspace = "<Name of your workspace>"
subscription_id = "<Subscription id>"
resource_grp = "<Name of your resource group where aml service is created>"
experiment_name = '<Name of your experiment you defined in dataprep.py>'
print("Starting trigger engine")
# Start creating
# Point file to conf directory containing details for the aml service
spn = ServicePrincipalAuthentication(tenant_id, app_id, app_key)
ws = Workspace(auth=spn,
workspace_name=workspace,
subscription_id=subscription_id,
resource_group=resource_grp)
#ws = Workspace.from_config(path="../conf/config.json")
ds = ws.get_default_datastore()
print(ds.datastore_type, ds.account_name, ds.container_name)
exp = Experiment(workspace=ws, name=experiment_name)
compute_target = ws.compute_targets[compute_name]
script_params = {'--data-folder': ds.as_mount(), '--regularization': 0.8}
est = Estimator(source_directory=script_folder,
script_params=script_params,
compute_target=compute_target,
entry_script='train.py',
conda_packages=['scikit-learn'])
print("Submitting Runs to AML compute " + compute_name)
run = exp.submit(config=est)
run.wait_for_completion(show_output=True) # specify True for a verbose log
def get_workspace():
dotenv.load_dotenv()
workspace_name = os.environ.get("WORKSPACE")
resource_group = os.environ.get("RESOURCE_GROUP")
subscription_id = os.environ.get("SUBSCRIPTION_ID")
tenant_id = os.environ.get("TENANT_ID")
app_id = os.environ.get("SP_APP_ID")
app_secret = os.environ.get("SP_APP_SECRET")
service_principal = ServicePrincipalAuthentication(
tenant_id=tenant_id,
service_principal_id=app_id,
service_principal_password=app_secret)
try:
aml_workspace = Workspace.get(name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
auth=service_principal)
return aml_workspace
except Exception as caught_exception:
print("Error while retrieving Workspace...")
print(str(caught_exception))
sys.exit(1)
def run(model_path, model_name, tenant_id, service_principal_id,
service_principal_password, subscription_id, resource_group, workspace,
tags):
auth_args = {
'tenant_id': tenant_id,
'service_principal_id': service_principal_id,
'service_principal_password': service_principal_password
}
ws_args = {
'auth': ServicePrincipalAuthentication(**auth_args),
'subscription_id': subscription_id,
'resource_group': resource_group
}
ws = Workspace.get(workspace, **ws_args)
print(ws.get_details())
print('\nSaving model {} to {}'.format(model_path, model_name))
# Model Path needs to be relative
model_path = relpath(model_path, '.')
model = Model.register(ws,
model_name=model_name,
model_path=model_path,
tags=tags)
print('Done!')
def main():
load_dotenv()
workspace_name = os.environ.get("BASE_NAME")+"-AML-WS"
resource_group = os.environ.get("BASE_NAME")+"-AML-RG"
subscription_id = os.environ.get("SUBSCRIPTION_ID")
tenant_id = os.environ.get("TENANT_ID")
experiment_name = os.environ.get("EXPERIMENT_NAME")
model_name = os.environ.get("MODEL_NAME")
app_id = os.environ.get('SP_APP_ID')
app_secret = os.environ.get('SP_APP_SECRET')
release_id = os.environ.get('RELEASE_RELEASEID')
build_id = os.environ.get('BUILD_BUILDID')
storageacctname = os.environ.get('STORAGE_ACCT_NAME')
storageacctkey = os.environ.get('STORAGE_ACCT_KEY')
containername = os.environ.get('STORAGE_BLOB_NAME')
service_principal = ServicePrincipalAuthentication(
tenant_id=tenant_id,
service_principal_id=app_id,
service_principal_password=app_secret)
aml_workspace = Workspace.get(
name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
auth=service_principal
)
# Find the pipeline that was published by the specified build ID
pipelines = PublishedPipeline.list(aml_workspace)
matched_pipes = []
for p in pipelines:
if p.version == build_id:
matched_pipes.append(p)
if(len(matched_pipes) > 1):
published_pipeline = None
raise Exception(f"Multiple active pipelines are published for build {build_id}.") # NOQA: E501
elif(len(matched_pipes) == 0):
published_pipeline = None
raise KeyError(f"Unable to find a published pipeline for this build {build_id}") # NOQA: E501
else:
published_pipeline = matched_pipes[0]
pipeline_parameters = {
"model_name": model_name,
"release_id": release_id,
"storageacctname": storageacctname,
"storageacctkey": storageacctkey,
"containername": containername
}
response = published_pipeline.submit(
aml_workspace,
experiment_name,
pipeline_parameters)
run_id = response.id
print("Pipeline run initiated ", run_id)
def get_workspace() -> Workspace:
tenant_id = os.environ["SP_TENANT_ID"]
app_id = os.environ["SP_APP_ID"]
secret = os.environ["SP_PASSWORD"]
sub_id = os.environ["SUBSCRIPTION"]
sp = ServicePrincipalAuthentication(tenant_id, app_id, secret)
ws = Workspace(sub_id, db_rg, az_ml_ws_name, auth=sp)
return ws
def get_workspace():
# Security for the RBAC principal
client_id = 'e0ae87de-e27b-433a-b7b5-017b0cd0808f'
client_secret = 'de90f973-5a74-4e1c-a3a1-fa8265ca8ccd'
tenant_id = '5c384fed-84cc-44a6-b34a-b060bf102a6e'
servicePrincipalAuth = ServicePrincipalAuthentication(
tenant_id, client_id, client_secret)
workspace = Workspace.from_config(auth=servicePrincipalAuth)
return workspace
def get_service_principal():
tenant_id = os.environ.get("TENANT_ID")
service_principal_id = os.environ.get("SERVICE_PRINCIPAL_ID")
service_principal_password = os.environ.get("SERVICE_PRINCIPAL_SECRET")
return ServicePrincipalAuthentication(
tenant_id=tenant_id,
service_principal_id=service_principal_id,
service_principal_password=service_principal_password)
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 get_serviceprincipal_auth(self):
svc_pr = None
if self.service_principal_password:
svc_pr = ServicePrincipalAuthentication(
tenant_id=self.service_principal_tenant_id,
service_principal_id=self.service_principal_id,
service_principal_password=self.service_principal_password
)
return svc_pr
def get_serviceprincipal_auth(self):
from azureml.core.authentication import ServicePrincipalAuthentication
svc_pr = None
if self.client_secret:
svc_pr = ServicePrincipalAuthentication(
tenant_id=self.directory_tenant_id,
service_principal_id=self.application_client_id,
service_principal_password=self.client_secret)
return svc_pr
def main():
load_dotenv()
workspace_name = os.environ.get("WORKSPACE_NAME")
resource_group = os.environ.get("RESOURCE_GROUP_NAME")
subscription_id = os.environ.get("SUBSCRIPTION_ID")
tenant_id = os.environ.get("TENANT_ID")
experiment_name = os.environ.get("EXPERIMENT_NAME")
model_name = os.environ.get("MODEL_NAME")
ckpt_path = os.environ.get("MODEL_CHECKPOINT_PATH")
app_id = os.environ.get('SP_APP_ID')
app_secret = os.environ.get('SP_APP_SECRET')
build_id = os.environ.get('BUILD_BUILDID')
datastore = os.environ.get('EPIS_DATASTORE')
container_name = os.environ.get('EPIS_CONTAINER')
service_principal = ServicePrincipalAuthentication(
tenant_id=tenant_id,
service_principal_id=app_id,
service_principal_password=app_secret)
aml_workspace = Workspace.get(name=workspace_name,
subscription_id=subscription_id,
resource_group=resource_group,
auth=service_principal)
pipelines = PublishedPipeline.list(aml_workspace)
matched_pipes = []
for p in pipelines:
if p.version == build_id:
matched_pipes.append(p)
if (len(matched_pipes) > 1):
published_pipeline = None
raise Exception(
f"Multiple active pipelines are published for build {build_id}.")
elif (len(matched_pipes) == 0):
published_pipeline = None
raise KeyError(
f"Unable to find a published pipeline for this build {build_id}")
else:
published_pipeline = matched_pipes[0]
pipeline_parameters = {
"model_name": model_name,
"ckpt_path": ckpt_path,
"datastore": datastore,
"storage_container": container_name
}
response = published_pipeline.submit(aml_workspace, experiment_name,
pipeline_parameters)
run_id = response.id
print("Pipeline run initiated ", run_id)
def get_ws():
auth_args = {
'tenant_id': os.environ.get('AZ_TENANT_ID'),
'service_principal_id': os.environ.get('AZ_CLIENT_ID'),
'service_principal_password': os.environ.get('AZ_CLIENT_SECRET')
}
ws = Workspace.get(name=os.environ.get('AZ_NAME'),
auth=ServicePrincipalAuthentication(**auth_args),
subscription_id=os.environ.get('AZ_SUBSCRIPTION_ID'),
resource_group=os.environ.get('AZ_RESOURCE_GROUP'))
return ws
def run(model_path, model_name):
auth_args = {
'tenant_id': os.environ['TENANT_ID'],
'service_principal_id': os.environ['SERVICE_PRINCIPAL_ID'],
'service_principal_password': os.environ['SERVICE_PRINCIPAL_PASSWORD']
}
ws_args = {
'auth': ServicePrincipalAuthentication(**auth_args),
'subscription_id': os.environ['SUBSCRIPTION_ID'],
'resource_group': os.environ['RESOURCE_GROUP']
}
ws = Workspace.get(os.environ['WORKSPACE_NAME'], **ws_args)
print(ws.get_details())
print('\nSaving model {} to {}'.format(model_path, model_name))
model = Model.register(ws, model_name=model_name, model_path=model_path)
print('Done!')
print('Checking for existing service {}'.format(model_name))
service_name = 'simplemnist-svc'
if model_name in ws.webservices:
print('Found it!\nRemoving Existing service...')
ws.webservices[model_name].delete()
print('Done!')
else:
print('Not found, creating new one!')
# image configuration
image_config = ContainerImage.image_configuration(
execution_script="score.py",
runtime="python",
conda_file="environment.yml")
# deployement configuration
aciconfig = AciWebservice.deploy_configuration(cpu_cores=1,
memory_gb=1,
description=model_name)
# deploy
service = Webservice.deploy_from_model(workspace=ws,
name=model_name,
models=[model],
image_config=image_config,
deployment_config=aciconfig)
service.wait_for_deployment(show_output=True)
#print logs
print(service.get_logs())
print('Done!')
def get_service_principal_auth():
tenant_id = os.environ[_TENANT_ID_ENV_NAME]
service_principal_id = os.environ[_SERVICE_PRINCIPAL_ID_ENV_NAME]
service_principal_password = os.environ[_SERVICE_PRINCIPAL_SECRET_ENV_NAME]
svc_pr = ServicePrincipalAuthentication(
tenant_id=tenant_id,
service_principal_id=service_principal_id,
service_principal_password=service_principal_password)
return svc_pr
def loadAuthCredentials(args):
with open(args.spconfig) as jsonFile:
data = json.load(jsonFile)
tenantid = data['tenantid']
applicationid = data['applicationid']
password = data['password']
if (args.verbose):
print("Tenant Id : {0}".format(tenantid))
print("Application Id is : {0}".format(applicationid))
svc_pr = ServicePrincipalAuthentication(tenantid, applicationid, password)
return svc_pr
def run():
global model
svc_pr = ServicePrincipalAuthentication(
tenant_id="1faf88fe-a998-4c5b-93c9-210a11d9a5c2",
service_principal_id="3683e499-d9d1-4b25-9e51-fc0c056415da",
service_principal_password=os.environ.get("AZUREML_PASSWORD"))
# retrieve the path to the model file using the model name
ws = Workspace.get(name='foram-workspace',
subscription_id='d90d34f0-1175-4d80-a89e-b74e16c0e31b',
auth=svc_pr)
model_path = Model.get_model_path('resnet18', _workspace=ws)
model = load_checkpoint(model_path)
def get_workspace(workspace: str, subscription: str, resource_group: str,
tenantId: str, clientId: str,
clientSecret: str) -> Workspace:
svcprincipal = ServicePrincipalAuthentication(
tenant_id=tenantId,
service_principal_id=clientId,
service_principal_password=clientSecret)
return Workspace.get(name=workspace,
subscription_id=subscription,
resource_group=resource_group,
auth=svcprincipal)
def get_workspace(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.get(name = workspace_name,
resource_group = resource_group,
subscription_id = subscription_id,
auth=svc_pr)
return workspace
def get_auth():
logger = logging.getLogger(__name__)
if os.environ.get("AML_SP_PASSWORD", None):
logger.debug("Trying to create Workspace with Service Principal")
aml_sp_password = os.environ.get("AML_SP_PASSWORD")
aml_sp_tennant_id = os.environ.get("AML_SP_TENNANT_ID")
aml_sp_username = os.environ.get("AML_SP_USERNAME")
auth = ServicePrincipalAuthentication(
tenant_id=aml_sp_tennant_id,
username=aml_sp_username,
password=aml_sp_password,
)
else:
logger.debug("Trying to create Workspace with CLI Authentication")
try:
auth = AzureCliAuthentication()
auth.get_authentication_header()
except AuthenticationException:
logger.debug("Trying to create Workspace with Interactive login")
auth = InteractiveLoginAuthentication()
return auth