Tworzenie wystąpienia obliczeniowe usługi Azure Machine Learning i zarządzanie nim

  • Artykuł

DOTYCZY:Rozszerzenie uczenia maszynowego platformy Azure w wersji 2 (bieżąca)Zestaw SDK języka Python azure-ai-ml w wersji 2 (bieżąca)

Dowiedz się, jak utworzyć wystąpienie obliczeniowe i zarządzać nim w obszarze roboczym usługi Azure Machine Learning.

Użyj wystąpienia obliczeniowego jako w pełni skonfigurowanego i zarządzanego środowiska programistycznego w chmurze. Na potrzeby programowania i testowania można również użyć wystąpienia jako celu obliczeniowego trenowania. Wystąpienie obliczeniowe może równolegle uruchamiać wiele zadań i ma kolejkę zadań. Jako środowisko programistyczne wystąpienie obliczeniowe nie może być udostępniane innym użytkownikom w obszarze roboczym.

W tym artykule omówiono sposób wykonywania następujących zadań:

Możesz również użyć skryptu instalacyjnego , aby utworzyć wystąpienie obliczeniowe z własnym środowiskiem niestandardowym.

Wystąpienia obliczeniowe mogą bezpiecznie uruchamiać zadania w środowisku sieci wirtualnej bez konieczności otwierania portów SSH przez przedsiębiorstwa. Zadanie jest wykonywane w środowisku konteneryzowanym i pakuje zależności modelu w kontenerze platformy Docker.

Uwaga

W tym artykule przedstawiono interfejs wiersza polecenia w wersji 2 w poniższych sekcjach. Jeśli nadal używasz interfejsu wiersza polecenia w wersji 1, zobacz Tworzenie interfejsu wiersza polecenia klastra obliczeniowego usługi Azure Machine Learning w wersji 1).

Wymagania wstępne

Utwórz

Szacowanie czasu: około 5 minut.

Tworzenie wystąpienia obliczeniowego to jednorazowy proces dla obszaru roboczego. Możesz ponownie użyć zasobów obliczeniowych jako stacji roboczej deweloperów lub jako celu obliczeniowego na potrzeby trenowania. Możesz mieć wiele wystąpień obliczeniowych dołączonych do obszaru roboczego.

Dedykowane rdzenie na region na przydział rodziny maszyn wirtualnych i łączny limit przydziału regionalnego, który ma zastosowanie do tworzenia wystąpienia obliczeniowego, jest ujednolicony i współużytkowany z limitem przydziału klastra obliczeniowego trenowania usługi Azure Machine Learning. Zatrzymanie wystąpienia obliczeniowego nie zwalnia limitu przydziału, aby upewnić się, że będzie można ponownie uruchomić wystąpienie obliczeniowe. Nie można zmienić rozmiaru maszyny wirtualnej wystąpienia obliczeniowego po jego utworzeniu.

Najszybszym sposobem utworzenia wystąpienia obliczeniowego jest wykonanie czynności związanych z tworzeniem zasobów, które należy rozpocząć.

Możesz też użyć następujących przykładów, aby utworzyć wystąpienie obliczeniowe z większą liczbie opcji:

DOTYCZY: Zestaw SDK języka Python azure-ai-ml w wersji 2 (bieżący)

# Compute Instances need to have a unique name across the region.
# Here we create a unique name with current datetime
from azure.ai.ml.entities import ComputeInstance, AmlCompute
import datetime

ci_basic_name = "basic-ci" + datetime.datetime.now().strftime("%Y%m%d%H%M")
ci_basic = ComputeInstance(name=ci_basic_name, size="STANDARD_DS3_v2")
ml_client.begin_create_or_update(ci_basic).result()

Aby uzyskać więcej informacji na temat klas, metod i parametrów używanych w tym przykładzie, zobacz następujące dokumenty referencyjne:

Utwórz w imieniu użytkownika

Jako administrator możesz utworzyć wystąpienie obliczeniowe w imieniu analityka danych i przypisać do niego wystąpienie za pomocą następujących elementów:

Analityk danych, dla którego utworzono wystąpienie obliczeniowe, musi mieć następujące uprawnienia kontroli dostępu opartej na rolach (RBAC) platformy Azure :

  • Microsoft.MachineLearningServices/workspaces/computes/start/action
  • Microsoft.MachineLearningServices/workspaces/computes/stop/action
  • Microsoft.MachineLearningServices/workspaces/computes/restart/action
  • Microsoft.MachineLearningServices/workspaces/computes/applicationaccess/action
  • Microsoft.MachineLearningServices/workspaces/computes/updateSchedules/action

Analityk danych może uruchomić, zatrzymać i ponownie uruchomić wystąpienie obliczeniowe. Mogą używać wystąpienia obliczeniowego dla:

  • Jupyter
  • JupyterLab
  • RStudio
  • Posit Workbench (dawniej RStudio Workbench)
  • Zintegrowane notesy

Włączanie zamykania bezczynności

Aby uniknąć naliczania opłat za wystąpienie obliczeniowe, które jest włączone, ale nieaktywne, możesz skonfigurować czas zamykania wystąpienia obliczeniowego z powodu braku aktywności.

Wystąpienie obliczeniowe jest uznawane za nieaktywne, jeśli spełnione są poniższe warunki:

  • Brak aktywnych sesji jądra Jupyter (co przekłada się na brak użycia notesów za pośrednictwem notesów Jupyter, JupyterLab lub interaktywnych notesów)
  • Brak aktywnych sesji terminalu Jupyter
  • Brak aktywnych przebiegów ani eksperymentów usługi Azure Machine Learning
  • Brak połączeń SSH
  • Brak połączeń programu VS Code; Aby wystąpienie obliczeniowe było uznawane za nieaktywne, należy zamknąć połączenie programu VS Code. Sesje są automatycznie przerywane, jeśli program VS Code nie wykryje działania przez 3 godziny.
  • W obliczeniach nie są uruchomione żadne aplikacje niestandardowe

Wystąpienie obliczeniowe nie zostanie uznane za bezczynne, jeśli jest uruchomiona żadna aplikacja niestandardowa. Istnieją również pewne podstawowe granice dotyczące okresów braku aktywności; Wystąpienie obliczeniowe musi być nieaktywne przez co najmniej 15 minut i maksymalnie trzy dni.

Ponadto jeśli wystąpienie obliczeniowe zostało już bezczynne przez określony czas, jeśli ustawienia zamknięcia bezczynności zostaną zaktualizowane do czasu krótszego niż bieżący czas bezczynności, zegar bezczynności zostanie zresetowany do 0. Jeśli na przykład wystąpienie obliczeniowe było już bezczynne przez 20 minut, a ustawienia zamykania zostaną zaktualizowane do 15 minut, zegar bezczynności zostanie zresetowany do 0.

Ustawienie można skonfigurować podczas tworzenia wystąpienia obliczeniowego lub dla istniejących wystąpień obliczeniowych za pośrednictwem następujących interfejsów:

DOTYCZY: Zestaw SDK języka Python azure-ai-ml w wersji 2 (bieżący)

Podczas tworzenia nowego wystąpienia obliczeniowego dodaj idle_time_before_shutdown_minutes parametr .

# Note that idle_time_before_shutdown has been deprecated.
ComputeInstance(name=ci_basic_name, size="STANDARD_DS3_v2", idle_time_before_shutdown_minutes="30")

Nie można zmienić czasu bezczynności istniejącego wystąpienia obliczeniowego za pomocą zestawu SDK języka Python.

Możesz również zmienić czas bezczynności przy użyciu:

  • Interfejs API REST

    Punkt końcowy:

    POST https://management.azure.com/subscriptions/{SUB_ID}/resourceGroups/{RG_NAME}/providers/Microsoft.MachineLearningServices/workspaces/{WS_NAME}/computes/{CI_NAME}/updateIdleShutdownSetting?api-version=2021-07-01

    Ciała:

    {
    "idleTimeBeforeShutdown": "PT30M" // this must be a string in ISO 8601 format
}

  • Szablony usługi ARM: konfigurowalne tylko podczas tworzenia nowego wystąpienia obliczeniowego

    // Note that this is just a snippet for the idle shutdown property in an ARM template
{
    "idleTimeBeforeShutdown":"PT30M" // this must be a string in ISO 8601 format
}

Obsługa zasad platformy Azure

Administratorzy mogą używać wbudowanej definicji Azure Policy, aby wymusić automatyczne zatrzymywanie wszystkich wystąpień obliczeniowych w danej subskrypcji/grupie zasobów.

  1. Przejdź do Azure Policy w Azure Portal.

  2. W obszarze "Definicje" poszukaj zasad zamykania bezczynności.

    Zrzut ekranu przedstawiający zasady zamykania bezczynności w Azure Portal.

  3. Przypisz zasady do wymaganego zakresu.

Możesz również utworzyć własne niestandardowe zasady platformy Azure. Jeśli na przykład poniższe zasady zostaną przypisane, wszystkie nowe wystąpienia obliczeniowe będą miały skonfigurowane automatyczne zatrzymanie z 60-minutowym okresem braku aktywności.

{
  "mode": "All",
  "policyRule": {
    "if": {
      "allOf": [
        {
          "field": "type",
          "equals": "Microsoft.MachineLearningServices/workspaces/computes"
        },
        {
          "field": "Microsoft.MachineLearningServices/workspaces/computes/computeType",
          "equals": "ComputeInstance"
        },
        {
          "anyOf": [
            {
              "field": "Microsoft.MachineLearningServices/workspaces/computes/idleTimeBeforeShutdown",
              "exists": false
            },
            {
              "value": "[empty(field('Microsoft.MachineLearningServices/workspaces/computes/idleTimeBeforeShutdown'))]",
              "equals": true
            }
          ]
        }
      ]
    },
    "then": {
      "effect": "append",
      "details": [
        {
          "field": "Microsoft.MachineLearningServices/workspaces/computes/idleTimeBeforeShutdown",
          "value": "PT60M"
        }
      ]
    }
  },
  "parameters": {}
}

Planowanie automatycznego uruchamiania i zatrzymywania

Zdefiniuj wiele harmonogramów automatycznego zamykania i automatycznego uruchamiania. Na przykład utwórz harmonogram rozpoczęcia o godzinie 9:00 i zatrzymaj się o godzinie 18:00 od poniedziałku do czwartku, a drugi harmonogram, który rozpocznie się o godzinie 19:00 i zatrzymaj się o godzinie 16:00 w piątek. Możesz utworzyć łącznie cztery harmonogramy na wystąpienie obliczeniowe.

Harmonogramy można również zdefiniować do tworzenia w imieniu wystąpień obliczeniowych. Możesz utworzyć harmonogram, który tworzy wystąpienie obliczeniowe w stanie zatrzymania. Zatrzymane wystąpienia obliczeniowe są przydatne podczas tworzenia wystąpienia obliczeniowego w imieniu innego użytkownika.

Przed zaplanowanym zamknięciem użytkownicy będą widzieć powiadomienie informujące o tym, że wystąpienie obliczeniowe wkrótce zostanie zamknięte. W tym momencie użytkownik może zdecydować się na odrzucenie nadchodzącego zdarzenia zamknięcia, jeśli na przykład znajduje się w środku korzystania z wystąpienia obliczeniowego.

Tworzenie harmonogramu w programie Studio

  1. Wypełnij formularz.

  2. Na drugiej stronie formularza otwórz pozycję Pokaż ustawienia zaawansowane.

  3. Wybierz pozycję Dodaj harmonogram , aby dodać nowy harmonogram.

    Zrzut ekranu: Dodawanie harmonogramu w ustawieniach zaawansowanych.

  4. Wybierz pozycję Uruchom wystąpienie obliczeniowe lub Zatrzymaj wystąpienie obliczeniowe.

  5. Wybierz strefę czasową.

  6. Wybierz godzinę uruchamiania lub czas zamknięcia.

  7. Wybierz dni, w których ten harmonogram jest aktywny.

    Zrzut ekranu: zaplanuj zamknięcie wystąpienia obliczeniowego.

  8. Wybierz ponownie pozycję Dodaj harmonogram , jeśli chcesz utworzyć inny harmonogram.

Po utworzeniu wystąpienia obliczeniowego można wyświetlać, edytować lub dodawać nowe harmonogramy z sekcji szczegółów wystąpienia obliczeniowego.

Uwaga

Etykiety strefy czasowej nie uwzględniają oszczędności światła dziennego. Na przykład (UTC+01:00) Amsterdam, Berlin, Bern, Rzym, Sztokholm, Wiedeń jest rzeczywiście UTC+02:00 w ciągu dnia oszczędności światła.

Tworzenie harmonogramu przy użyciu interfejsu wiersza polecenia

DOTYCZY:Rozszerzenie uczenia maszynowego platformy Azure w wersji 2 (bieżąca)

az ml compute create -f create-instance.yml

Gdzie plik create-instance.yml to:

$schema: https://azuremlschemas.azureedge.net/latest/computeInstance.schema.json 
name: schedule-example-i
type: computeinstance
size: STANDARD_DS3_v2
schedules:
   compute_start_stop:
      - action: stop
        trigger:
         type: cron
         start_time: "2021-03-10T21:21:07"
         time_zone: Pacific Standard Time
         expression: 0 18 * * *

Tworzenie harmonogramu przy użyciu zestawu SDK

DOTYCZY: Zestaw SDK języka Python azure-ai-ml w wersji 2 (bieżący)

from azure.ai.ml.entities import ComputeInstance, ComputeSchedules, ComputeStartStopSchedule, RecurrenceTrigger, RecurrencePattern
from azure.ai.ml import MLClient
from azure.ai.ml.constants import TimeZone
from azure.identity import DefaultAzureCredential

subscription_id = "sub-id"
resource_group = "rg-name"
workspace = "ws-name"
# get a handle to the workspace
ml_client = MLClient(
    DefaultAzureCredential(), subscription_id, resource_group, workspace
)

ci_minimal_name = "ci-name"

rec_trigger = RecurrenceTrigger(start_time="yyyy-mm-ddThh:mm:ss", time_zone=TimeZone.INDIA_STANDARD_TIME, frequency="week", interval=1, schedule=RecurrencePattern(week_days=["Friday"], hours=15, minutes=[30]))
myschedule = ComputeStartStopSchedule(trigger=rec_trigger, action="start")
com_sch = ComputeSchedules(compute_start_stop=[myschedule])

my_compute = ComputeInstance(name=ci_minimal_name, schedules=com_sch)
ml_client.compute.begin_create_or_update(my_compute)

Tworzenie harmonogramu przy użyciu szablonu Resource Manager

Automatyczne uruchamianie i zatrzymywanie wystąpienia obliczeniowego można zaplanować przy użyciu szablonu Resource Manager.

W szablonie Resource Manager dodaj:

"schedules": "[parameters('schedules')]"

Następnie użyj wyrażeń cron lub LogicApps, aby zdefiniować harmonogram, który uruchamia lub zatrzymuje wystąpienie w pliku parametrów:

        "schedules": {
        "value": {
        "computeStartStop": [
          {
            "triggerType": "Cron",
            "cron": {              
              "timeZone": "UTC",
              "expression": "0 18 * * *"
            },
            "action": "Stop",
            "status": "Enabled"
          },
          {
            "triggerType": "Cron",
            "cron": {              
              "timeZone": "UTC",
              "expression": "0 8 * * *"
            },
            "action": "Start",
            "status": "Enabled"
          },
          { 
            "triggerType": "Recurrence", 
            "recurrence": { 
              "frequency": "Day", 
              "interval": 1, 
              "timeZone": "UTC", 
              "schedule": { 
                "hours": [17], 
                "minutes": [0]
              } 
            }, 
            "action": "Stop", 
            "status": "Enabled" 
          } 
        ]
      }
    }

  • Akcja może mieć wartość "Start" lub "Stop".

  • W przypadku typu Recurrence wyzwalacza użyj tej samej składni co aplikacja logiki z tym schematem cyklu.

  • W przypadku typu wyzwalacza użyj standardowej cronskładni cron:

    // Crontab expression format: 
// 
// * * * * * 
// - - - - - 
// | | | | | 
// | | | | +----- day of week (0 - 6) (Sunday=0) 
// | | | +------- month (1 - 12) 
// | | +--------- day of month (1 - 31) 
// | +----------- hour (0 - 23) 
// +------------- min (0 - 59) 
// 
// Star (*) in the value field above means all legal values as in 
// braces for that column. The value column can have a * or a list 
// of elements separated by commas. An element is either a number in 
// the ranges shown above or two numbers in the range separated by a 
// hyphen (meaning an inclusive range).

Azure Policy obsługę domyślnego harmonogramu

Użyj Azure Policy, aby wymusić harmonogram zamknięcia istnieje dla każdego wystąpienia obliczeniowego w subskrypcji lub domyślnego harmonogramu, jeśli nic nie istnieje. Poniżej przedstawiono przykładowe zasady domyślnego harmonogramu zamykania o godzinie 10 PM PST.

{
    "mode": "All",
    "policyRule": {
     "if": {
      "allOf": [
       {
        "field": "Microsoft.MachineLearningServices/workspaces/computes/computeType",
        "equals": "ComputeInstance"
       },
       {
        "field": "Microsoft.MachineLearningServices/workspaces/computes/schedules",
        "exists": "false"
       }
      ]
     },
     "then": {
      "effect": "append",
      "details": [
       {
        "field": "Microsoft.MachineLearningServices/workspaces/computes/schedules",
        "value": {
         "computeStartStop": [
          {
           "triggerType": "Cron",
           "cron": {
            "startTime": "2021-03-10T21:21:07",
            "timeZone": "Pacific Standard Time",
            "expression": "0 22 * * *"
           },
           "action": "Stop",
           "status": "Enabled"
          }
         ]
        }
       }
      ]
     }
    }
}

Przypisywanie tożsamości zarządzanej

Tożsamość zarządzaną przypisaną przez system lub użytkownika można przypisać do wystąpienia obliczeniowego, aby uwierzytelnić się względem innych zasobów platformy Azure, takich jak magazyn. Uwierzytelnianie przy użyciu tożsamości zarządzanych pomaga zwiększyć bezpieczeństwo obszaru roboczego i zarządzanie nim. Na przykład można zezwolić użytkownikom na dostęp do danych treningowych tylko wtedy, gdy zalogowano się do wystąpienia obliczeniowego. Możesz też użyć typowej tożsamości zarządzanej przypisanej przez użytkownika, aby zezwolić na dostęp do określonego konta magazynu.

Wystąpienie obliczeniowe można utworzyć przy użyciu tożsamości zarządzanej w usłudze Azure Machine Learning Studio:

  1. Wypełnij formularz, aby utworzyć nowe wystąpienie obliczeniowe.
  2. Wybierz pozycję Dalej: Ustawienia zaawansowane.
  3. Włącz przypisywanie tożsamości zarządzanej.
  4. Wybierz pozycję Przypisane przez system lub Przypisane przez użytkownika w obszarze Typ tożsamości.
  5. W przypadku wybrania pozycji Przypisane przez użytkownika wybierz subskrypcję i nazwę tożsamości.

Za pomocą zestawu SDK w wersji 2 można utworzyć wystąpienie obliczeniowe z przypisaną przez system tożsamością zarządzaną:

from azure.ai.ml import MLClient
from azure.identity import ManagedIdentityCredential
client_id = os.environ.get("DEFAULT_IDENTITY_CLIENT_ID", None)
credential = ManagedIdentityCredential(client_id=client_id)
ml_client = MLClient(credential, sub_id, rg_name, ws_name)
data = ml_client.data.get(name=data_name, version="1")

Możesz również użyć zestawu SDK w wersji 1:

from azureml.core.authentication import MsiAuthentication
from azureml.core import Workspace
client_id = os.environ.get("DEFAULT_IDENTITY_CLIENT_ID", None)
auth = MsiAuthentication(identity_config={"client_id": client_id})
workspace = Workspace.get("chrjia-eastus", auth=auth, subscription_id="381b38e9-9840-4719-a5a0-61d9585e1e91", resource_group="chrjia-rg", location="East US")

Interfejs wiersza polecenia w wersji 2 umożliwia utworzenie wystąpienia obliczeniowego z przypisaną przez system tożsamością zarządzaną:

az ml compute create --name myinstance --identity-type SystemAssigned --type ComputeInstance --resource-group my-resource-group --workspace-name my-workspace

Możesz również użyć interfejsu wiersza polecenia w wersji 2 z plikiem yaml, na przykład w celu utworzenia wystąpienia obliczeniowego z tożsamością zarządzaną przypisaną przez użytkownika:

Azure Machine Learning compute create --file compute.yaml --resource-group my-resource-group --workspace-name my-workspace

Definicja tożsamości znajduje się w pliku compute.yaml:

https://azuremlschemas.azureedge.net/latest/computeInstance.schema.json
name: myinstance
type: computeinstance
identity:
  type: user_assigned
  user_assigned_identities: 
    - resource_id: identity_resource_id

Po utworzeniu tożsamości zarządzanej przyznaj tożsamość zarządzaną co najmniej rolę Czytelnik danych obiektów blob usługi Storage na koncie magazynu danych, zobacz Uzyskiwanie dostępu do usług magazynu. Następnie podczas pracy nad wystąpieniem obliczeniowym tożsamość zarządzana jest automatycznie używana do uwierzytelniania w magazynach danych.

Uwaga

Nazwa utworzonej tożsamości zarządzanej systemu będzie mieć format /workspace-name/computes/compute-instance-name w usłudze Azure Active Directory.

Tożsamość zarządzana można również użyć ręcznie do uwierzytelniania względem innych zasobów platformy Azure. W poniższym przykładzie pokazano, jak używać go do uzyskiwania tokenu dostępu usługi Azure Resource Manager:

import requests

def get_access_token_msi(resource):
    client_id = os.environ.get("DEFAULT_IDENTITY_CLIENT_ID", None)
    resp = requests.get(f"{os.environ['MSI_ENDPOINT']}?resource={resource}&clientid={client_id}&api-version=2017-09-01", headers={'Secret': os.environ["MSI_SECRET"]})
    resp.raise_for_status()
    return resp.json()["access_token"]

arm_access_token = get_access_token_msi("https://management.azure.com")

Aby użyć interfejsu wiersza polecenia platformy Azure z tożsamością zarządzaną do uwierzytelniania, określ identyfikator klienta tożsamości jako nazwę użytkownika podczas logowania:

az login --identity --username $DEFAULT_IDENTITY_CLIENT_ID

Uwaga

Nie można używać azcopy podczas próby użycia tożsamości zarządzanej. azcopy login --identity nie będzie działać.

Dodawanie aplikacji niestandardowych, takich jak RStudio lub Posit Workbench

Podczas tworzenia wystąpienia obliczeniowego można skonfigurować inne aplikacje, takie jak RStudio lub Posit Workbench (dawniej RStudio Workbench). Wykonaj następujące kroki w programie Studio, aby skonfigurować aplikację niestandardową w wystąpieniu obliczeniowym

  1. Wypełnij formularz, aby utworzyć nowe wystąpienie obliczeniowe
  2. Wybierz pozycję Dalej: Ustawienia zaawansowane
  3. Wybierz pozycję Dodaj aplikację w sekcji Konfiguracja aplikacji niestandardowej (RStudio Workbench itp.)

Zrzut ekranu przedstawiający konfigurację usługi niestandardowej.

Setup Posit Workbench (dawniej RStudio Workbench)

RStudio jest jednym z najpopularniejszych rozwiązań IDE wśród deweloperów języka R dla projektów uczenia maszynowego i nauki o danych. Możesz łatwo skonfigurować aplikację Posit Workbench, która zapewnia dostęp do programu RStudio wraz z innymi narzędziami programistycznymi w celu uruchamiania w wystąpieniu obliczeniowym, przy użyciu własnej licencji posit i uzyskiwania dostępu do bogatego zestawu funkcji, który oferuje aplikacja Posit Workbench

  1. Wykonaj kroki wymienione powyżej, aby dodać aplikację podczas tworzenia wystąpienia obliczeniowego.
  2. Wybierz pozycję Posit Workbench (przynieś własną licencję) na liście rozwijanej Aplikacja i wprowadź klucz licencji Posit Workbench w polu Klucz licencji . Licencję usługi Posit Workbench lub licencję próbną możesz uzyskać z witryny posit.
  3. Wybierz pozycję Utwórz, aby dodać aplikację Posit Workbench do wystąpienia obliczeniowego.

Zrzut ekranu przedstawiający ustawienia aplikacji Posit Workbench.

Ważne

Jeśli używasz obszaru roboczego łącza prywatnego, upewnij się, że obraz platformy Docker pkg-containers.githubusercontent.com i ghcr.io są dostępne. Ponadto użyj opublikowanego portu w zakresie 8704-8993. W przypadku aplikacji Posit Workbench (dawniej RStudio Workbench) upewnij się, że licencja jest dostępna, zapewniając dostęp sieciowy do https://www.wyday.comprogramu .

Uwaga

  • Obsługa uzyskiwania dostępu do magazynu plików obszaru roboczego z aplikacji Posit Workbench nie jest jeszcze dostępna.
  • Jeśli podczas uzyskiwania dostępu do wielu wystąpień aplikacji Posit Workbench zostanie wyświetlony komunikat "400 Nieprawidłowe żądanie. Błąd nagłówka żądania lub pliku cookie zbyt duży" — użyj nowej przeglądarki lub dostępu z przeglądarki w trybie incognito.

Konfigurowanie programu RStudio (open source)

Aby użyć programu RStudio, skonfiguruj aplikację niestandardową w następujący sposób:

  1. Wykonaj kroki wymienione powyżej, aby dodać aplikację podczas tworzenia wystąpienia obliczeniowego.

  2. Wybierz pozycję Aplikacja niestandardowa na liście rozwijanej Aplikacja

  3. Skonfiguruj nazwę aplikacji , której chcesz użyć.

  4. Skonfiguruj aplikację do uruchamiania na porcie8787 docelowym — obraz platformy Docker dla programu RStudio open source wymienionych poniżej musi zostać uruchomiony na tym porcie docelowym.

  5. Skonfiguruj aplikację, do której ma być uzyskiwany dostęp na porcie opublikowanym — możesz skonfigurować dostęp do aplikacji na innym porcie 8787 opublikowanym, jeśli chcesz.

  6. Wskaż obraz platformy Docker na ghcr.io/azure/rocker-rstudio-ml-verse:latest.

  7. Wybierz pozycję Utwórz, aby skonfigurować aplikację RStudio jako aplikację niestandardową w wystąpieniu obliczeniowym.

Zrzut ekranu przedstawia formularz umożliwiający skonfigurowanie programu RStudio jako aplikacji niestandardowej

Ważne

Jeśli używasz obszaru roboczego łącza prywatnego, upewnij się, że obraz platformy Docker pkg-containers.githubusercontent.com i ghcr.io są dostępne. Ponadto użyj opublikowanego portu w zakresie 8704-8993. W przypadku aplikacji Posit Workbench (dawniej RStudio Workbench) upewnij się, że licencja jest dostępna, zapewniając dostęp sieciowy do https://www.wyday.comprogramu .

Konfigurowanie innych aplikacji niestandardowych

Skonfiguruj inne aplikacje niestandardowe w wystąpieniu obliczeniowym, udostępniając aplikację na obrazie platformy Docker.

  1. Wykonaj kroki wymienione powyżej, aby dodać aplikację podczas tworzenia wystąpienia obliczeniowego.
  2. Wybierz pozycję Aplikacja niestandardowa na liście rozwijanej Aplikacja .
  3. Skonfiguruj nazwę aplikacji, port docelowy , na którym chcesz uruchomić aplikację, port opublikowany , na którym chcesz uzyskać dostęp do aplikacji, oraz obraz platformy Docker zawierający aplikację.
  4. Opcjonalnie dodaj zmienne środowiskowe , których chcesz użyć dla aplikacji.
  5. Użyj instalacji bind, aby dodać dostęp do plików na domyślnym koncie magazynu:
    • Określ /home/azureuser/cloudfiles dla ścieżki hosta.
    • Określ /home/azureuser/cloudfiles dla ścieżki kontenera.
    • Wybierz pozycję Dodaj, aby dodać tę instalowanie. Ponieważ pliki są instalowane, zmiany wprowadzone w nich będą dostępne w innych wystąpieniach obliczeniowych i aplikacjach.
  6. Wybierz pozycję Utwórz, aby skonfigurować aplikację niestandardową w wystąpieniu obliczeniowym.

Zrzut ekranu przedstawiający niestandardowe ustawienia aplikacji.

Ważne

Jeśli używasz obszaru roboczego łącza prywatnego, upewnij się, że obraz platformy Docker pkg-containers.githubusercontent.com i ghcr.io są dostępne. Ponadto użyj opublikowanego portu w zakresie 8704-8993. W przypadku aplikacji Posit Workbench (dawniej RStudio Workbench) upewnij się, że licencja jest dostępna, zapewniając dostęp sieciowy do https://www.wyday.comprogramu .

Uzyskiwanie dostępu do aplikacji niestandardowych w programie Studio

Uzyskaj dostęp do aplikacji niestandardowych skonfigurowanych w programie Studio:

  1. Po lewej stronie wybierz pozycję Obliczenia.
  2. Na karcie Wystąpienie obliczeniowe zobacz aplikacje w kolumnie Aplikacje .

Zrzut ekranu przedstawia dostęp studio dla aplikacji niestandardowych.

Uwaga

Skonfigurowanie aplikacji niestandardowej może potrwać kilka minut, dopóki nie będzie można uzyskać do niej dostępu za pośrednictwem powyższych linków. Ilość czasu zajętego będzie zależeć od rozmiaru obrazu używanego dla aplikacji niestandardowej. Jeśli podczas próby uzyskania dostępu do aplikacji zostanie wyświetlony komunikat o błędzie 502, poczekaj na skonfigurowanie aplikacji i spróbuj ponownie.

Zarządzanie

Uruchamianie, zatrzymywanie, ponowne uruchamianie i usuwanie wystąpienia obliczeniowego. Wystąpienie obliczeniowe nie jest automatycznie skalowane w dół, dlatego należy pamiętać o zatrzymaniu zasobu, aby uniknąć ciągłego naliczania opłat. Zatrzymanie wystąpienia obliczeniowego powoduje cofnięcie jego przydziału. Następnie uruchom go ponownie, gdy jest potrzebny. Zatrzymanie wystąpienia obliczeniowego zatrzymuje naliczanie opłat za godziny obliczeniowe, nadal jednak są naliczane opłaty za dysk, publiczny adres IP i standardowy moduł równoważenia obciążenia.

Możesz utworzyć harmonogram dla wystąpienia obliczeniowego, aby automatycznie uruchamiać i zatrzymywać się na podstawie godziny i dnia tygodnia.

Porada

Wystąpienie obliczeniowe korzysta z dysku systemu operacyjnego o pojemności 120 GB. Jeśli zabraknie miejsca na dysku, użyj terminalu , aby wyczyścić co najmniej 1–2 GB przed zatrzymaniem lub ponownym uruchomieniem wystąpienia obliczeniowego. Nie należy zatrzymywać wystąpienia obliczeniowego, wystawiając polecenie sudo shutdown z terminalu. Rozmiar dysku tymczasowego w wystąpieniu obliczeniowym zależy od wybranego rozmiaru maszyny wirtualnej i jest instalowany na /mnt.

DOTYCZY: Zestaw SDK języka Python azure-ai-ml w wersji 2 (bieżący)

W poniższych przykładach nazwa wystąpienia obliczeniowego jest przechowywana w zmiennej ci_basic_name.

  • Uzyskiwanie stanu

    from azure.ai.ml.entities import ComputeInstance, AmlCompute

# Get compute
ci_basic_state = ml_client.compute.get(ci_basic_name)

  • Stop

    from azure.ai.ml.entities import ComputeInstance, AmlCompute

# Stop compute
ml_client.compute.begin_stop(ci_basic_name).wait()

  • Rozpocznij

    from azure.ai.ml.entities import ComputeInstance, AmlCompute

# Start compute
ml_client.compute.begin_start(ci_basic_name).wait()

  • Uruchom ponownie

    from azure.ai.ml.entities import ComputeInstance, AmlCompute

# Restart compute
ml_client.compute.begin_restart(ci_basic_name).wait()

  • Usuń

    from azure.ai.ml.entities import ComputeInstance, AmlCompute

ml_client.compute.begin_delete(ci_basic_name).wait()

Kontrola dostępu oparta na rolach platformy Azure umożliwia kontrolowanie, którzy użytkownicy w obszarze roboczym mogą tworzyć, usuwać, uruchamiać, zatrzymywać, uruchamiać ponownie wystąpienie obliczeniowe. Wszyscy użytkownicy w roli współautora i właściciela obszaru roboczego mogą tworzyć, usuwać, uruchamiać, zatrzymywać i uruchamiać ponownie wystąpienia obliczeniowe w obszarze roboczym. Jednak tylko twórca określonego wystąpienia obliczeniowego lub użytkownik przypisany, jeśli został utworzony w ich imieniu, może uzyskiwać dostęp do programów Jupyter, JupyterLab i RStudio w tym wystąpieniu obliczeniowym. Wystąpienie obliczeniowe jest przeznaczone dla jednego użytkownika, który ma dostęp główny. Ten użytkownik ma dostęp do aplikacji Jupyter/JupyterLab/RStudio uruchomionej w wystąpieniu. Wystąpienie obliczeniowe będzie miało logowanie jednokrotne użytkownika, a wszystkie akcje będą używać tożsamości tego użytkownika na potrzeby kontroli dostępu opartej na rolach platformy Azure i przypisywania zadań eksperymentu. Dostęp SSH jest kontrolowany za pośrednictwem mechanizmu kluczy publicznych/prywatnych.

Te akcje można kontrolować za pomocą kontroli dostępu opartej na rolach platformy Azure:

  • Microsoft.MachineLearningServices/workspaces/computes/read
  • Microsoft.MachineLearningServices/workspaces/computes/write
  • Microsoft.MachineLearningServices/workspaces/computes/delete
  • Microsoft.MachineLearningServices/workspaces/computes/start/action
  • Microsoft.MachineLearningServices/workspaces/computes/stop/action
  • Microsoft.MachineLearningServices/workspaces/computes/restart/action
  • Microsoft.MachineLearningServices/workspaces/computes/updateSchedules/action

Aby utworzyć wystąpienie obliczeniowe, musisz mieć uprawnienia do następujących akcji:

  • Microsoft.MachineLearningServices/workspaces/computes/write
  • Microsoft.MachineLearningServices/workspaces/checkComputeNameAvailability/action

Inspekcja i obserwowanie wersji wystąpienia obliczeniowego

Po wdrożeniu wystąpienia obliczeniowego nie zostanie ono automatycznie zaktualizowane. Firma Microsoft publikuje nowe obrazy maszyn wirtualnych co miesiąc. Aby poznać opcje utrzymywania najnowszej wersji, zobacz Zarządzanie lukami w zabezpieczeniach.

Aby śledzić, czy wersja systemu operacyjnego wystąpienia jest aktualna, możesz wykonać zapytanie dotyczące jego wersji przy użyciu interfejsu wiersza polecenia, zestawu SDK lub interfejsu użytkownika programu Studio.

DOTYCZY: Zestaw SDK języka Python azure-ai-ml w wersji 2 (bieżący)

from azure.ai.ml.entities import ComputeInstance, AmlCompute

# Display operating system version
instance = ml_client.compute.get("myci")
print instance.os_image_metadata

Aby uzyskać więcej informacji na temat klas, metod i parametrów używanych w tym przykładzie, zobacz następujące dokumenty referencyjne:

Administratorzy IT mogą używać Azure Policy do monitorowania spisu wystąpień w obszarach roboczych w portalu zgodności Azure Policy. Przypisz wbudowane zasady Audit Azure Machine Learning Compute Instances z nieaktualnym systemem operacyjnym w ramach subskrypcji platformy Azure lub zakresu grupy zarządzania platformy Azure.

Następne kroki