def __deploy_service(self, image, compute): service_config = self.__config['deploy'] services = AksWebservice.list(self.__ws) service = services.find_by_property('name', service_config['name']) if service: service.update(auth_enabled=service_config['auth']) service.wait_for_deployment(show_output=True) return service aks_config = AksWebservice.deploy_configuration( auth_enabled=True, max_request_wait_time=75000, replica_max_concurrent_requests=100, autoscale_enabled=False, num_replicas=15) aks_service_name = service_config['name'] aks_service = Webservice.deploy_from_image( workspace=self.__ws, name=aks_service_name, image=image, deployment_config=aks_config, deployment_target=compute) aks_service.wait_for_deployment(show_output=True) print(aks_service.state) return aks_service
def deploy_service(ws, model, inference_config, service_name, compute_target): tags = {'model': '{}:{}'.format(model.name, model.version)} try: service = Webservice(ws, service_name) print("Service {} exists, update it".format(service_name)) service.update(models=[model], inference_config=inference_config, tags=tags) except Exception: print('deploy a new service {}'.format(service_name)) deployment_config = AksWebservice.deploy_configuration( cpu_cores=1, memory_gb=2, tags=tags, collect_model_data=True, enable_app_insights=True) service = Model.deploy(ws, service_name, [model], inference_config, deployment_config, compute_target) service.wait_for_deployment(show_output=True) if service.auth_enabled: token = service.get_keys()[0] elif service.token_auth_enabled: token = service.get_token()[0] return service.scoring_uri, token
def deploy_new_webservice(ws, compute_name, webservice_name, image): aks_target = ws.compute_targets[compute_name] aks_config = AksWebservice.deploy_configuration(collect_model_data=True, enable_app_insights=True) service = Webservice.deploy_from_image(workspace=ws, name=webservice_name, image=image, deployment_config=aks_config, deployment_target=aks_target) service.wait_for_deployment(show_output=True) print(service.state)
def deploy(local, aks, aci, num_cores, mem_gb, compute_name): # Get the workspace ws = Workspace.from_config() # Create inference configuration based on the environment definition and the entry script # yolo = Environment.from_conda_specification(name="env", file_path="yolo.yml") yolo = Environment.from_pip_requirements( name="yolo", file_path="./deployed_requirements.txt") # yolo.save_to_directory('') yolo.register(workspace=ws) inference_config = InferenceConfig(entry_script="azure.py", environment=yolo, source_directory="yolov5") # Retrieve registered model model = Model(ws, id="lpr:1") deploy_target = None if local: # Create a local deployment, using port 8890 for the web service endpoint deployment_config = LocalWebservice.deploy_configuration(port=8890) elif aks: # Create a AKS deployment deployment_config = AksWebservice.deploy_configuration( cpu_cores=num_cores, memory_gb=mem_gb, compute_target_name=compute_name) deploy_target = ComputeTarget(workspace=ws, name=compute_name) # if deploy_target.get_status() != "Succeeded": # print(f"Deploy Target: {deploy_target.get_status()}") # deploy_target.wait_for_completion(show_output=True) elif aks: # Create a AKS deployment deployment_config = AciWebservice.deploy_configuration( cpu_cores=num_cores, memory_gb=mem_gb, compute_target_name=compute_name) else: raise NotImplementedError("Choose deploy target please") # Deploy the service print("Deploying:") service = Model.deploy(workspace=ws, name="lpr", models=[model], inference_config=inference_config, deployment_config=deployment_config, overwrite=True, deployment_target=deploy_target) # Wait for the deployment to complete print("Deploying:") service.wait_for_deployment(True) # Display the port that the web service is available on if local: print(service.port)
def createWebservice(workspace, container_image, service_name, replica_count, cores_count, compute_target): ''' TODO: Should allow for the overwrite flag. Attach a azureml.core.webservice.Webservice for a given container on an AKS cluster. If a WebService already exists (by name) on the given workspace, return it instead. PARAMS: workspace : azureml.core.Workspace : Existing AMLS Workspace container_image : azureml.core.image.ContainerImage : Name of an existing AKS cluster service_name : String : Name of the webservice (deployment) in the AMLS workpsace. replica_count : int : Number of requested instances of container on cluster. cores_count : int : Number of cores to allocate to each container compute_target : azureml.core.compute.AksCompute : AKS cluster to create the service on RETURNS: azureml.core.webservice.Webservice ''' web_service = None services = Webservice.list(workspace=workspace, image_name=container_image.name) if len(services) > 0: for svc in services: if svc.name == service_name: print("Returning existing deployed web service ....", service_name) web_service = svc break if web_service == None: print("Creating new web service.....", service_name) aks_config = AksWebservice.deploy_configuration( num_replicas=replica_count, cpu_cores=cores_count) web_service = Webservice.deploy_from_image( workspace=workspace, name=service_name, image=container_image, deployment_config=aks_config, deployment_target=compute_target, ) web_service.wait_for_deployment(show_output=True) return web_service
def deploy_to_aks(workspace, model_image, aks_target, prod_webservice_name="dsswe-mprodm"): from azureml.core.webservice import Webservice, AksWebservice # Deploy a model image to AKS print("Deploying to AKS...") # Set configuration and service name prod_webservice_deployment_config = AksWebservice.deploy_configuration() # Deploy from image prod_webservice = Webservice.deploy_from_image(workspace=workspace, name=prod_webservice_name, image=model_image, deployment_config=prod_webservice_deployment_config, deployment_target=aks_target) # Wait for the deployment to complete prod_webservice.wait_for_deployment(show_output=True) print("Deployment to AKS completed sucessfully") return prod_webservice
def create_aks_service(name: str, image_config: ImageConfig, models: List[Model], target: ComputeTarget, ws: Workspace) -> Webservice: print("Loading AKS deploy config from deployconfig_aks.yml") deploy_conf = AksWebservice.deploy_configuration() print(models) service = Webservice.deploy_from_model(workspace=ws, name=name, deployment_target=target, models=models, deployment_config=deploy_conf, image_config=image_config) service.wait_for_deployment(show_output=True) return service
def deploy_aks(workspace, model_azure, endpoint_name, inference_config, aks_name): aks_target = AksCompute(workspace, aks_name) aks_config = AksWebservice.deploy_configuration() aks_service = Model.deploy(workspace=workspace, name=endpoint_name, models=[model_azure], inference_config=inference_config, deployment_config=aks_config, deployment_target=aks_target, overwrite=True) aks_service.wait_for_deployment(show_output = True) print(f"Endpoint : {endpoint_name} was successfully deployed to AKS") print(f"Endpoint : {aks_service.scoring_uri} created") print('')
def deploy(workspace, name, model, script, source_directory, environment=None, target='local', cpu_cores=1, memory_gb=1, compute_target_name=None): inference_config = InferenceConfig(entry_script=script, source_directory=source_directory, environment=environment) if target == 'local': deployment_config = LocalWebservice.deploy_configuration(port=8890) elif target == 'aci': deployment_config = AciWebservice.deploy_configuration( cpu_cores=cpu_cores, memory_gb=memory_gb) elif target == 'aks': if compute_target_name is None: print("compute_target_name required when target='aks'") return None deployment_config = AksWebservice.deploy_configuration( cpu_cores=cpu_cores, memory_gb=memory_gb, compute_target_name=compute_target_name, auth_enabled=False) try: service = Webservice(workspace, name) except WebserviceException: service = None if service is None: service = Model.deploy(workspace, name, [model], inference_config, deployment_config) else: print( "Existing service with that name found, updating InferenceConfig\n" "If you meant to redeploy or change the deployment option, first " "delete the existing service.") service.update(models=[model], inference_config=inference_config) return service
def deploy_image(): ws = get_workspace() azure_image = get_image() # Set the web service configuration (using default here with app insights) aks_config = AksWebservice.deploy_configuration(enable_app_insights=True) # Unique service name service_name = AKS_NAME aks_target = get_cluster() # Webservice creation using single command aks_service = Webservice.deploy_from_image(workspace=ws, name=service_name, deployment_config=aks_config, image=azure_image, deployment_target=aks_target) aks_service.wait_for_deployment(show_output=True)
def deploy_to_AKS(workspace, attachment_name, service_name, models, inference_config, token_auth_enabled=True, cpu_cores=1, memory_gb=1, overwrite=True): services = workspace.webservices if service_name in services and overwrite: print('found existing service named {}, delete it right now...'.format(service_name)) services[service_name].delete() # Only one type of Auth may be enabled if token_auth_enabled: # key auth auth_enabled = False print('auth type: {}'.format('token' if token_auth_enabled else 'key')) aks_target = AksCompute(workspace, attachment_name) # If deploying to a cluster configured for dev/test, ensure that it was created with enough # cores and memory to handle this deployment configuration. Note that memory is also used by # things such as dependencies and AML components. deployment_config = AksWebservice.deploy_configuration(cpu_cores=cpu_cores, memory_gb=memory_gb, token_auth_enabled=token_auth_enabled, auth_enabled=auth_enabled) service = Model.deploy(workspace, service_name, models, inference_config, deployment_config, aks_target) service.wait_for_deployment(show_output=True) print(service.state) return service
print('Found existing compute target') except ComputeTargetException: print('Creating a new compute target...') # Provision AKS cluster with GPU machine prov_config = AksCompute.provisioning_configuration(vm_size="Standard_NC6") # Create the cluster aks_target = ComputeTarget.create(workspace=ws, name=aks_name, provisioning_configuration=prov_config) aks_target.wait_for_completion(show_output=True) # Define the deployment configuration gpu_aks_config = AksWebservice.deploy_configuration(autoscale_enabled=False, num_replicas=3, cpu_cores=2, memory_gb=4) # Define the inference configuration myenv = Environment.from_conda_specification( name="testEnv", file_path= "C:/Users/Danilo.Bento/Icon Dropbox/DEVDATA/RO/DEVELOPMENT/SIB2/tutorials/model5/mod5_deploy/deploy_env.yaml" ) myenv.docker.base_image = DEFAULT_GPU_IMAGE inference_config = InferenceConfig( #entry_script=os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'yolov5','score.py'), #entry_script="./yolov5/score.py", entry_script="score.py", environment=myenv, source_directory=
def deploy(): # Load credentials print("::debug::Loading azure credentials") with open('creds.json') as json_file: azure_credentials = json.load(json_file) #destribute credentials over variables tenant_id = azure_credentials['tenantId'] app_id = azure_credentials['clientId'] app_secret = azure_credentials['clientSecret'] subscription_id = azure_credentials['subscriptionId'] rm_endpoint = azure_credentials['resourceManagerEndpointUrl'] #Load model name and model version print("::debug::Loading input values") model_name = 'newsletter-info' mv = '1' #convert into int print("::debug::Casting input values") try: model_version = int(mv) except TypeError as exception: print(f"::debug::Could not cast model version to int: {exception}") model_version = None cloud = "AzureCloud" # Authenticate Azure try: sp = ServicePrincipalAuthentication( tenant_id=tenant_id, service_principal_id=app_id, service_principal_password=app_secret, cloud=cloud) except AuthenticationException as exception: print( f"::error::Could not retrieve user token. Please paste output of `az ad sp create-for-rbac --name <your-sp-name> --role contributor --scopes /subscriptions/<your-subscriptionId>/resourceGroups/<your-rg> --sdk-auth` as value of secret variable: AZURE_CREDENTIALS: {exception}" ) raise AuthenticationException #Load workspace and resource group print("::debug::Loading Workspace values") ws_path = 'delphai-common-ml' resource_group = 'tf-ml-workspace' #Load Azure workspace try: ws = Workspace.get(name=ws_path, auth=sp, subscription_id=subscription_id, resource_group=resource_group) except AuthenticationException as exception: print( f"::error::Could not retrieve user token. Please paste output of `az ad sp create-for-rbac --name <your-sp-name> --role contributor --scopes /subscriptions/<your-subscriptionId>/resourceGroups/<your-rg> --sdk-auth` as value of secret variable: AZURE_CREDENTIALS: {exception}" ) raise AuthenticationException #Load Model print("::debug::Loading model") try: model = Model(workspace=ws, name=model_name, version=model_version) except WebserviceException as exception: print( f"::error::Could not load model with provided details: {exception}" ) raise AMLConfigurationException( f"Could not load model with provided details: {exception}") # Loading deployment target print("::debug::Loading deployment target") try: deployment_target = ComputeTarget(workspace=ws, name='delphai-common') except ComputeTargetException: deployment_target = None except TypeError: deployment_target = None # Loading entry and conda file source = 'tests/model' print("::debug::Loading entry_file & Conda file") entry_file = 'entry.py' entry_file_path = os.path.join(source, entry_file) conda_file = 'conda.yml' conda_ffile_path = os.path.join(source, conda_file) print(conda_ffile_path) try: env = Environment.from_conda_specification(name=model_name, file_path=conda_ffile_path) except: print( f'::debug:: failed to create environment from {conda_ffile_path}') try: inference_configration = InferenceConfig(entry_script=entry_file_path, environment=env) except: print(f'::debug:: Failed to create InferenceConfig') #print('::debug:: Make sure conda.yml and entry.py are in the [src] directory') print('::debug:: get namespace and replicas') replicas = os.environ.get('INPUT_REPLICAS') or '3' try: replicas = int(replicas) except TypeError as exception: print(f"::debug::Could not cast model version to int: {exception}") replicas = 3 deployment_name = os.environ.get('INPUT_DEPLOYMENT_NAME', default=model_name.replace("_", "-")) create_namespace(app_id=app_id, app_secret=app_secret, tenant=tenant_id, namespace=deployment_name) deployment_configration = AksWebservice.deploy_configuration( autoscale_enabled=False, num_replicas=replicas, namespace=deployment_name) # Deploying model print("::debug::Deploying model") override = os.environ.get('INPUT_OVERRIDE') or 'yes' if override == 'yes': override = True elif override == 'no': override = False try: service = Model.deploy(workspace=ws, name=deployment_name, models=[model], inference_config=inference_configration, deployment_config=deployment_configration, deployment_target=deployment_target, overwrite=override) service.wait_for_deployment(show_output=True) except WebserviceException as exception: print(f"::error::Model deployment failed with exception: {exception}") service_logs = service.get_logs() # Give Time to Ku8 to create PODS time.sleep(60) if service.state != "Healthy": try: service_logs = service.get_logs() except: print( f"::error::Model deployment Might be failied, Please check in lens for your deployments" )
exist_ok=True) # Provision AKS cluster prov_config = AksCompute.provisioning_configuration(vm_size="Standard_D14") prov_config.enable_ssl(leaf_domain_label=https_cert) # Create the cluster aks_target = ComputeTarget.create(workspace=ws, name=aks_name, provisioning_configuration=prov_config) inference_config = InferenceConfig(runtime="python", entry_script="aml_app.py", conda_file="myenv.yml", extra_docker_file_steps='dockerfile') aks_python_bot = AksWebservice.deploy_configuration(autoscale_enabled=False, num_replicas=3, cpu_cores=2, memory_gb=4, auth_enabled=False) aks_service = Model.deploy(ws, models=['aml_app.py'], inference_config=inference_config, deployment_config=aks_python_bot, deployment_target=aks_target, name=aks_service_name) aks_service.wait_for_deployment(show_output=True) print(aks_service.state)
# now inference config is ready now So now we need to configure the compute to which the service will be deployed #if we are going for AKS cluster then we need to create the cluster and a compute target before deployment #creating the AKS cluster(Azure kubernetes service) from azureml.core.compute import ComputeTarget, AksCompute cluster_name = 'aks-cluster' compute_config = AksCompute.provisioning_configuration(location="eastus") production_cluster = ComputeTarget.create(ws, cluster_name, compute_config) production_cluster.wait_for_completion(show_output=True) from azureml.core.webservice import AksWebservice classifier_deploy_config = AksWebservice.deploy_configuration(cpu_core=1, memory_gb=1) #finally deploting the model from azureml.core.model import Model model = ws.models['classification_model'] service = Model.deploy(workspace=ws, name='classifier-service', models=[model], inference_config=class_inference_config, deployment_config=classifier_deploy_config, deployment_target=production_cluster) service.wait_for_deployment(show_output=True)
with open(os.path.join(project_folder, "myenv.yml"), "w") as f: f.write(myenv.serialize_to_string()) shutil.copy("./scripts/score_flowers.py", './') # configure the image image_config = ContainerImage.image_configuration( execution_script="score_flowers.py", runtime="python", conda_file=os.path.join(project_folder, "myenv.yml")) aks_config = AksWebservice.deploy_configuration( cpu_cores=1, memory_gb=1, #collect_model_data=True, enable_app_insights=True, tags={ "data": "flower_photos", "method": "TensorFlow" }, description='Predict flowers with TensorFlow') print("Creating the image and deploy as web service...") service = Webservice.deploy_from_model(workspace=ws, name=service_name, deployment_config=aks_config, deployment_target=aks_target, models=[model_graph, model_labels], image_config=image_config) service.wait_for_deployment(show_output=True) print(service.state)
vm_size="Standard_F2", location="eastus") print( "No AKS found in aks_webservice.json. Creating new Aks: {} and AKS Webservice: {}" .format(aks_name, aks_service_name)) # Create the cluster aks_target = ComputeTarget.create(workspace=ws, name=aks_name, provisioning_configuration=prov_config) aks_target.wait_for_completion(show_output=True) print(aks_target.provisioning_state) print(aks_target.provisioning_errors) # Use the default configuration (can also provide parameters to customize) aks_config = AksWebservice.deploy_configuration(enable_app_insights=True) service = Webservice.deploy_from_image( workspace=ws, name=aks_service_name, image=image, deployment_config=aks_config, deployment_target=aks_target, ) service.wait_for_deployment(show_output=True) print(service.state) print("Deployed AKS Webservice: {} \nWebservice Uri: {}".format( service.name, service.scoring_uri)) # Writing the AKS details to /aml_config/aks_webservice.json
status = aks_target.get_status() while status != 'Succeeded' and status != 'Failed': print('current status: {} - waiting...'.format(status)) time.sleep(10) status = aks_target.get_status() from azureml.core.webservice import Webservice, AksWebservice aks_service_name = 'sklearn-mnist-aks-svc' # Set the web service configuration (using default here) aks_config = AksWebservice.deploy_configuration( cpu_cores=1, memory_gb=1, tags={ "data": "MNIST", "method": "sklearn" }, description='Predict MNIST with sklearn') aks_service = Webservice.deploy_from_image(workspace=ws, name=aks_service_name, image=image, deployment_config=aks_config, deployment_target=aks_target) aks_service.wait_for_deployment(show_output=True) print(aks_service.state) print("Testing deployed service via HTTP call...") import requests
model = None runs = ws.experiments[experiment_name].get_runs() run = next(runs) while run.get_status() != "Completed" or model is None: run = next(runs) try: model = run.register_model(experiment_name, model_path="model") except: pass # create deployment configuration aks_config = AksWebservice.deploy_configuration( compute_target_name="aks-cpu-deploy", cpu_cores=2, memory_gb=5, tags={ "data": "diabetes", "method": "sklearn" }, description="Predict using webservice", ) # create webservice webservice, azure_model = mlflow.azureml.deploy( model_uri=f"runs:/{run.id}/model", workspace=ws, deployment_config=aks_config, service_name="sklearn-diabetes-" + str(randint(10000, 99999)), model_name="sklearn-diabetes-example", ) # test webservice
provisioning_configuration=prov_config) aks_target.wait_for_completion(show_output=True) print(aks_target.provisioning_state) print(aks_target.provisioning_errors) # Check AKS cluster state status = aks_target.get_status() while status != 'Succeeded' and status != 'Failed': print('current status: {} - waiting...'.format(status)) time.sleep(10) status = aks_target.get_status() print("Deploying the service to Azure Kubernetes Service...") # Activate Data Collection and App Insights through updating AKS Webservice configuration aks_config = AksWebservice.deploy_configuration(collect_model_data=True, enable_app_insights=True) # Deploy your service aks_service_name = 'diabetes-aks-svc' aks_service = Webservice.deploy_from_image(workspace=ws, name=aks_service_name, image=image, deployment_config=aks_config, deployment_target=aks_target) aks_service.wait_for_deployment(show_output=True) print(aks_service.state) print("Testing deployed service via SDK...") # Test Service
aks_config = AksWebservice.deploy_configuration( autoscale_enabled=aks_service_settings["autoscale_enabled"], autoscale_min_replicas=aks_service_settings["autoscale_min_replicas"], autoscale_max_replicas=aks_service_settings["autoscale_max_replicas"], autoscale_refresh_seconds=aks_service_settings[ "autoscale_refresh_seconds"], autoscale_target_utilization=aks_service_settings[ "autoscale_target_utilization"], collect_model_data=aks_service_settings["collect_model_data"], auth_enabled=aks_service_settings["auth_enabled"], cpu_cores=profiling_result["cpu"], memory_gb=profiling_result["memory"], enable_app_insights=aks_service_settings["enable_app_insights"], scoring_timeout_ms=aks_service_settings["scoring_timeout_ms"], replica_max_concurrent_requests=aks_service_settings[ "replica_max_concurrent_requests"], max_request_wait_time=aks_service_settings["max_request_wait_time"], num_replicas=aks_service_settings["num_replicas"], primary_key=aks_service_settings["primary_key"], secondary_key=aks_service_settings["secondary_key"], tags=deployment_settings["image"]["tags"], properties=deployment_settings["image"]["properties"], description=deployment_settings["image"]["description"], gpu_cores=aks_service_settings["gpu_cores"], period_seconds=aks_service_settings["period_seconds"], initial_delay_seconds=aks_service_settings["initial_delay_seconds"], timeout_seconds=aks_service_settings["timeout_seconds"], success_threshold=aks_service_settings["success_threshold"], failure_threshold=aks_service_settings["failure_threshold"], namespace=aks_service_settings["namespace"], token_auth_enabled=aks_service_settings["token_auth_enabled"])
from azureml.core.image import ContainerImage from azureml.core.webservice import AksWebservice, Webservice # If deploying to a cluster configured for dev/test, ensure that it was created with enough # cores and memory to handle this deployment configuration. Note that memory is also used by # things such as dependencies and AML components. aks_config = AksWebservice.deploy_configuration(autoscale_enabled=True, autoscale_min_replicas=1, autoscale_max_replicas=2, autoscale_refresh_seconds=10, autoscale_target_utilization=70, auth_enabled=True, cpu_cores=2, memory_gb=1, scoring_timeout_ms=5000, replica_max_concurrent_requests=2, max_request_wait_time=5000, enable_app_insights=True, collect_model_data=True) try: aks_service = Webservice(name = aks_service_name, workspace = ws) print('Found the webservice, deleting the service to add a new one') aks_service.delete() print('Old webservice is deleted') except Exception: print("This webservice doesn't exist") finally: print('Deploying the new web service')
def main(): # Loading input values print("::debug::Loading input values") model_name = os.environ.get("INPUT_MODEL_NAME", default=None) model_version = os.environ.get("INPUT_MODEL_VERSION", default=None) # Casting input values print("::debug::Casting input values") try: model_version = int(model_version) except TypeError as exception: print(f"::debug::Could not cast model version to int: {exception}") model_version = None except ValueError as exception: print(f"::debug::Could not cast model version to int: {exception}") model_version = None # Loading azure credentials print("::debug::Loading azure credentials") azure_credentials = os.environ.get("INPUT_AZURE_CREDENTIALS", default="{}") try: azure_credentials = json.loads(azure_credentials) except JSONDecodeError: print( "::error::Please paste output of `az ad sp create-for-rbac --name <your-sp-name> --role contributor --scopes /subscriptions/<your-subscriptionId>/resourceGroups/<your-rg> --sdk-auth` as value of secret variable: AZURE_CREDENTIALS" ) raise AMLConfigurationException( "Incorrect or poorly formed output from azure credentials saved in AZURE_CREDENTIALS secret. See setup in https://github.com/Azure/aml-compute/blob/master/README.md" ) # Checking provided parameters print("::debug::Checking provided parameters") validate_json(data=azure_credentials, schema=azure_credentials_schema, input_name="AZURE_CREDENTIALS") # Mask values print("::debug::Masking parameters") mask_parameter(parameter=azure_credentials.get("tenantId", "")) mask_parameter(parameter=azure_credentials.get("clientId", "")) mask_parameter(parameter=azure_credentials.get("clientSecret", "")) mask_parameter(parameter=azure_credentials.get("subscriptionId", "")) # Loading parameters file print("::debug::Loading parameters file") parameters_file = os.environ.get("INPUT_PARAMETERS_FILE", default="deploy.json") parameters_file_path = os.path.join(".cloud", ".azure", parameters_file) try: with open(parameters_file_path) as f: parameters = json.load(f) except FileNotFoundError: print( f"::debug::Could not find parameter file in {parameters_file_path}. Please provide a parameter file in your repository if you do not want to use default settings (e.g. .cloud/.azure/deploy.json)." ) parameters = {} # Checking provided parameters print("::debug::Checking provided parameters") validate_json(data=parameters, schema=parameters_schema, input_name="PARAMETERS_FILE") # Loading Workspace print("::debug::Loading AML Workspace") sp_auth = ServicePrincipalAuthentication( tenant_id=azure_credentials.get("tenantId", ""), service_principal_id=azure_credentials.get("clientId", ""), service_principal_password=azure_credentials.get("clientSecret", "")) config_file_path = os.environ.get("GITHUB_WORKSPACE", default=".cloud/.azure") config_file_name = "aml_arm_config.json" try: ws = Workspace.from_config(path=config_file_path, _file_name=config_file_name, auth=sp_auth) except AuthenticationException as exception: print( f"::error::Could not retrieve user token. Please paste output of `az ad sp create-for-rbac --name <your-sp-name> --role contributor --scopes /subscriptions/<your-subscriptionId>/resourceGroups/<your-rg> --sdk-auth` as value of secret variable: AZURE_CREDENTIALS: {exception}" ) raise AuthenticationException except AuthenticationError as exception: print(f"::error::Microsoft REST Authentication Error: {exception}") raise AuthenticationError except AdalError as exception: print( f"::error::Active Directory Authentication Library Error: {exception}" ) raise AdalError except ProjectSystemException as exception: print(f"::error::Workspace authorizationfailed: {exception}") raise ProjectSystemException # Loading deployment target print("::debug::Loading deployment target") try: deployment_target = ComputeTarget(workspace=ws, name=parameters.get( "deployment_compute_target", "")) except ComputeTargetException: deployment_target = None except TypeError: deployment_target = None # Loading model print("::debug::Loading model") try: model = Model(workspace=ws, name=model_name, version=model_version) except WebserviceException as exception: print( f"::error::Could not load model with provided details: {exception}" ) raise AMLConfigurationException( f"Could not load model with provided details: {exception}") # Creating inference config print("::debug::Creating inference config") if os.environ.get("CONTAINER_REGISTRY_ADRESS", None) is not None: container_registry = ContainerRegistry() container_registry.address = os.environ.get( "CONTAINER_REGISTRY_ADRESS", None) container_registry.username = os.environ.get( "CONTAINER_REGISTRY_USERNAME", None) container_registry.password = os.environ.get( "CONTAINER_REGISTRY_PASSWORD", None) else: container_registry = None try: inference_config = InferenceConfig( entry_script=parameters.get("inference_entry_script", "score.py"), runtime=parameters.get("runtime", "python"), conda_file=parameters.get("conda_file", "environment.yml"), extra_docker_file_steps=parameters.get("extra_docker_file_steps", None), source_directory=parameters.get("inference_source_directory", "code/deploy/"), enable_gpu=parameters.get("enable_gpu", None), description=parameters.get("description", None), base_image=parameters.get("base_image", None), base_image_registry=container_registry, cuda_version=parameters.get("cuda_version", None)) except WebserviceException as exception: print( f"::debug::Failed to create InferenceConfig. Trying to create no code deployment: {exception}" ) inference_config = None except TypeError as exception: print( f"::debug::Failed to create InferenceConfig. Trying to create no code deployment: {exception}" ) inference_config = None # Loading run config print("::debug::Loading run config") model_resource_config = model.resource_configuration cpu_cores = get_resource_config(config=parameters.get("cpu_cores", None), resource_config=model_resource_config, config_name="cpu") memory_gb = get_resource_config(config=parameters.get("memory_gb", None), resource_config=model_resource_config, config_name="memory_in_gb") gpu_cores = get_resource_config(config=parameters.get("gpu_cores", None), resource_config=model_resource_config, config_name="gpu") # Creating deployment config print("::debug::Creating deployment config") if type(deployment_target) is AksCompute: deployment_config = AksWebservice.deploy_configuration( autoscale_enabled=parameters.get("autoscale_enabled", None), autoscale_min_replicas=parameters.get("autoscale_min_replicas", None), autoscale_max_replicas=parameters.get("autoscale_max_replicas", None), autoscale_refresh_seconds=parameters.get( "autoscale_refresh_seconds", None), autoscale_target_utilization=parameters.get( "autoscale_target_utilization", None), collect_model_data=parameters.get("model_data_collection_enabled", None), auth_enabled=parameters.get("authentication_enabled", None), cpu_cores=cpu_cores, memory_gb=memory_gb, enable_app_insights=parameters.get("app_insights_enabled", None), scoring_timeout_ms=parameters.get("scoring_timeout_ms", None), replica_max_concurrent_requests=parameters.get( "replica_max_concurrent_requests", None), max_request_wait_time=parameters.get("max_request_wait_time", None), num_replicas=parameters.get("num_replicas", None), primary_key=os.environ.get("PRIMARY_KEY", None), secondary_key=os.environ.get("SECONDARY_KEY", None), tags=parameters.get("tags", None), properties=parameters.get("properties", None), description=parameters.get("description", None), gpu_cores=gpu_cores, period_seconds=parameters.get("period_seconds", None), initial_delay_seconds=parameters.get("initial_delay_seconds", None), timeout_seconds=parameters.get("timeout_seconds", None), success_threshold=parameters.get("success_threshold", None), failure_threshold=parameters.get("failure_threshold", None), namespace=parameters.get("namespace", None), token_auth_enabled=parameters.get("token_auth_enabled", None)) else: deployment_config = AciWebservice.deploy_configuration( cpu_cores=cpu_cores, memory_gb=memory_gb, tags=parameters.get("tags", None), properties=parameters.get("properties", None), description=parameters.get("description", None), location=parameters.get("location", None), auth_enabled=parameters.get("authentication_enabled", None), ssl_enabled=parameters.get("ssl_enabled", None), enable_app_insights=parameters.get("app_insights_enabled", None), ssl_cert_pem_file=parameters.get("ssl_cert_pem_file", None), ssl_key_pem_file=parameters.get("ssl_key_pem_file", None), ssl_cname=parameters.get("ssl_cname", None), dns_name_label=parameters.get("dns_name_label", None), primary_key=os.environ.get("PRIMARY_KEY", None), secondary_key=os.environ.get("SECONDARY_KEY", None), collect_model_data=parameters.get("model_data_collection_enabled", None), cmk_vault_base_url=os.environ.get("CMK_VAULT_BASE_URL", None), cmk_key_name=os.environ.get("CMK_KEY_NAME", None), cmk_key_version=os.environ.get("CMK_KEY_VERSION", None)) # Deploying model print("::debug::Deploying model") try: # Default service name repository_name = os.environ.get("GITHUB_REPOSITORY").split("/")[-1] branch_name = os.environ.get("GITHUB_REF").split("/")[-1] default_service_name = f"{repository_name}-{branch_name}".lower( ).replace("_", "-")[:32] service = Model.deploy(workspace=ws, name=parameters.get("name", default_service_name), models=[model], inference_config=inference_config, deployment_config=deployment_config, deployment_target=deployment_target, overwrite=True) service.wait_for_deployment(show_output=True) except WebserviceException as exception: print(f"::error::Model deployment failed with exception: {exception}") service_logs = service.get_logs() raise AMLDeploymentException( f"Model deployment failedlogs: {service_logs} \nexception: {exception}" ) # Checking status of service print("::debug::Checking status of service") if service.state != "Healthy": service_logs = service.get_logs() print( f"::error::Model deployment failed with state '{service.state}': {service_logs}" ) raise AMLDeploymentException( f"Model deployment failed with state '{service.state}': {service_logs}" ) if parameters.get("test_enabled", False): # Testing service print("::debug::Testing service") root = os.environ.get("GITHUB_WORKSPACE", default=None) test_file_path = parameters.get("test_file_path", "code/test/test.py") test_file_function_name = parameters.get("test_file_function_name", "main") print("::debug::Adding root to system path") sys.path.insert(1, f"{root}") print("::debug::Importing module") test_file_path = f"{test_file_path}.py" if not test_file_path.endswith( ".py") else test_file_path try: test_spec = importlib.util.spec_from_file_location( name="testmodule", location=test_file_path) test_module = importlib.util.module_from_spec(spec=test_spec) test_spec.loader.exec_module(test_module) test_function = getattr(test_module, test_file_function_name, None) except ModuleNotFoundError as exception: print( f"::error::Could not load python script in your repository which defines theweb service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}" ) raise AMLConfigurationException( f"Could not load python script in your repository which defines the web service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}" ) except FileNotFoundError as exception: print( f"::error::Could not load python script or function in your repository which defines the web service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}" ) raise AMLConfigurationException( f"Could not load python script or function in your repository which defines the web service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}" ) except AttributeError as exception: print( f"::error::Could not load python script or function in your repository which defines the web service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}" ) raise AMLConfigurationException( f"Could not load python script or function in your repository which defines the web service tests (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}" ) # Load experiment config print("::debug::Loading experiment config") try: test_function(service) except TypeError as exception: print( f"::error::Could not load experiment config from your module (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}" ) raise AMLConfigurationException( f"Could not load experiment config from your module (Script: /{test_file_path}, Function: {test_file_function_name}()): {exception}" ) except Exception as exception: print( f"::error::The webservice tests did not complete successfully: {exception}" ) raise AMLDeploymentException( f"The webservice tests did not complete successfully: {exception}" ) # Deleting service if desired if parameters.get("delete_service_after_deployment", False): service.delete() else: # Create outputs print("::debug::Creating outputs") print(f"::set-output name=service_scoring_uri::{service.scoring_uri}") print(f"::set-output name=service_swagger_uri::{service.swagger_uri}") print( "::debug::Successfully finished Azure Machine Learning Deploy Action")
"Werkzeug==0.16.1" ], python_version="3.6.2") myenv.python.conda_dependencies.add_channel("conda-forge") myenv.spark.packages = [ SparkPackage("com.microsoft.ml.spark", "mmlspark_2.11", "0.15"), SparkPackage("com.microsoft.azure", "azure-storage", "2.0.0"), SparkPackage("org.apache.hadoop", "hadoop-azure", "2.7.0") ] myenv.spark.repositories = ["https://mmlspark.azureedge.net/maven"] inference_config = InferenceConfig(entry_script='scoreSpark.py', environment=myenv) deployment_config = AksWebservice.deploy_configuration( auth_enabled=False, collect_model_data=True, enable_app_insights=True, cpu_cores=2, memory_gb=2) aks_target = AksCompute(ws, aks_name) service = Model.deploy(ws, service_name, [model], inference_config, deployment_config, aks_target) service.wait_for_deployment(show_output=True) print(service.state) print(service.scoring_uri) aks_webservice = {} aks_webservice['aks_name'] = service.name aks_webservice['aks_url'] = service.scoring_uri with open('../conf/' + service_name + '.json', 'w') as outfile:
# Use the default configuration (can also provide parameters to customize) prov_config = AksCompute.provisioning_configuration() # Create the cluster aks_target = ComputeTarget.create( workspace=ws, name=aksName, provisioning_configuration=prov_config) print("Wait for AKS compute target....") aks_target.wait_for_completion(show_output=True) print(aks_target.provisioning_state) print(aks_target.provisioning_errors) if not aks_service: #Set the web service configuration (using default here) aks_config = AksWebservice.deploy_configuration() aks_service = Webservice.deploy_from_image( workspace=ws, name=aksServiceName, image=containerImage, deployment_config=aks_config, deployment_target=aks_target) print("Wait for AKS service....") aks_service.wait_for_deployment(show_output=True) print(aks_service.state) # Now get ready to call the service key1, Key2 = aks_service.get_keys() print(key1)
# In[77]: inference_config = InferenceConfig(entry_script='inference.py', environment=environment) # ## 2.10 Define the configuration of the inference container # Give the single "replica" container running on AKS 0.2 GB of RAM and 0.1 CPU core. Do not scale the number of containers depending on the load. For more configuration options see https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.webservice.akswebservice # In[78]: aks_config = AksWebservice.deploy_configuration( autoscale_enabled=False, cpu_cores=0.1, description='Student admissions logistic regression model', memory_gb=0.2, num_replicas=1, tags={'project': project}) # ## 2.11 Use an existing AKS cluster as the deployment target # In[79]: attach_config = AksCompute.attach_configuration( cluster_name=project, cluster_purpose='DevTest', # allows 1 node resource_group=project) # The cell below attaches the existing Kubernetes cluster as a compute target in the Azure ML workspace. It may take about 5 minutes.
print("No AKS found. Creating new Aks: {} and AKS Webservice: {}".format( aks_name, aks_service_name)) prov_config = AksCompute.provisioning_configuration(location=aks_region) # Create the cluster aks_target = ComputeTarget.create(workspace=ws, name=aks_name, provisioning_configuration=prov_config) aks_target.wait_for_completion(show_output=True) print(aks_target.provisioning_state) print(aks_target.provisioning_errors) print("Creating new webservice") # Create the web service configuration (using defaults) aks_config = AksWebservice.deploy_configuration(description=args.description, tags={ 'name': aks_name, 'image_id': image.id }) service = Webservice.deploy_from_image(workspace=ws, name=aks_service_name, image=image, deployment_config=aks_config, deployment_target=aks_target) service.wait_for_deployment(show_output=True) print(service.state) api_key, _ = service.get_keys() print( "Deployed AKS Webservice: {} \nWebservice Uri: {} \nWebservice API Key: {}" .format(service.name, service.scoring_uri, api_key))
for task in tasks: model_name = f'{args.project_name}-model-{task}' if tasks.get(task)['type'] in ['ner', 'om']: # NOTE: tasks 3 and 5 do not have a model continue model = Model(ws, model_name) models.append( model ) logging.warning(f'[INFO] Added Model : {model.name} (v{model.version})') # Deployment Target if deploy.get('type') == 'ACI': compute_config = AciWebservice.deploy_configuration(cpu_cores=deploy.get('cpu'), memory_gb=deploy.get('memory'), auth_enabled=auth_enabled) #2 elif deploy.get('type') == 'AKS': compute_config = AksWebservice.deploy_configuration() # Prepare Environment environment = Environment('env') conda_packages = ['pytorch', 'torchvision'] pip_packages = ['azureml-defaults'] + pip_packages environment.python.conda_dependencies = CondaDependencies.create(pip_packages=pip_packages, conda_packages=conda_packages) inference_config = InferenceConfig(entry_script='src/infer.py', source_directory='.', environment=environment) # Create or update service service_name = f'{args.project_name}-{env}'.replace('_','-') ## Create web service
# MAGIC The code in the following cell will deploy the model selected from MLFlow in the cells above # COMMAND ---------- # MAGIC %md # MAGIC ## Create a new web service deployment from a model image # COMMAND ---------- from azureml.core.webservice import Webservice, AksWebservice # Set configuration and service name webservice_name = "<prod_webservice_name>" #default configuration can be modified for custom requirements webservice_deployment_config = AksWebservice.deploy_configuration() # Deploy from image selected above webservice = Webservice.deploy_from_image( workspace=workspace, name=webservice_name, image=model_image, deployment_config=webservice_deployment_config, deployment_target=aks_target) #wait for the webservice to be deployed webservice.wait_for_deployment(show_output=True) # COMMAND ---------- print(webservice.get_logs())
compute_config) # Wait for the cluster to complete, show the output log aks_gpu_cluster.wait_for_completion(show_output=True) ######################################################################################################### deployment_env = Environment.from_conda_specification( name="deployment_env", file_path="./configuration/deployment_env.yml") inference_config = InferenceConfig(entry_script="./scripts/score/score.py", environment=deployment_env) # Set the web service configuration (using default here) aks_config = AksWebservice.deploy_configuration( cpu_cores=2, auth_enabled=True, # this flag generates API keys to secure access memory_gb=8, #tags={'name': 'mnist', 'framework': 'Keras'}, #max_request_wait_time=300000,scoring_timeout_ms=300000, description='X-Ray ML Estimator AKS endpoint') ######################################################################################################### service_name = 'mlops-estimator-model-aks' # Remove any existing service under the same name. try: Webservice(ws, service_name).delete() except WebserviceException: pass aks_service = Model.deploy(workspace=ws,