SI APPLICA A:
Estensione ML dell'interfaccia della riga di comando di Azure v2 (corrente)
SDK Python azure-ai-ml v2 (corrente)
Avviso
Importare dati da origini esterne (anteprima) e Data Connections (anteprima) in Azure Machine Learning sono deprecate e non saranno disponibili dopo il 30 settembre 2026. Fino ad allora, è possibile continuare a usare queste funzionalità senza interruzioni. Dopo tale data, tutti i carichi di lavoro che dipendono da essi verranno interrotti.
Recommended action: Eseguire la migrazione delle importazioni di dati esterni in Microsoft Fabric e usare archivi dati Azure Machine Learning per rendere disponibili i dati in Azure Machine Learning.
Questo articolo illustra come connettersi a origini dati esterne per rendere i dati disponibili per Azure Machine Learning. Imparerai anche come connetterti a diversi servizi esterni non relativi ai dati. È possibile usare l'interfaccia della riga di comando di Azure Machine Learning, Azure Machine Learning SDK per Python o Machine Learning Studio per creare queste connessioni.
Una connessione di Azure Machine Learning archivia in modo sicuro nomi utente e password come segreti in un key vault. Le connessioni di Azure fungono da proxy per il Key Vault, e le interazioni con le connessioni sono interazioni dirette con Azure Key Vault. Il controllo degli accessi basato sui ruoli di Key Vault gestisce l'accesso alle risorse dati. Non è necessario gestire direttamente le credenziali dopo la memorizzazione nel vault delle chiavi.
Azure supporta le connessioni alle origini esterne seguenti per la disponibilità dei dati:
- Fiocco
- database SQL di Azure
- Amazon S3
Importante
Questa funzionalità è attualmente disponibile in anteprima pubblica. Questa versione di anteprima viene fornita senza un contratto di servizio e non è consigliabile per i carichi di lavoro di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero avere funzionalità limitate.
Per altre informazioni, vedere Condizioni supplementari per l'utilizzo delle anteprime di Microsoft Azure.
Prerequisiti
Una sottoscrizione Azure con la versione gratuita o a pagamento di Azure Machine Learning.
Un'area di lavoro Azure Machine Learning.
Interfaccia della riga di comando di Azure con la versione dell'estensione ml 2.15.1 o successiva.
Se si dispone di una versione o di un'estensione interfaccia della riga di comando di Azure precedente, usare il codice seguente per disinstallarlo e installarlo.
az extension remove -n ml
az extension add -n ml --yes
az extension show -n ml 2.15.1
Una sottoscrizione Azure con la versione gratuita o a pagamento di Azure Machine Learning.
Un'area di lavoro Azure Machine Learning.
L'SDK Azure Machine Learning per Python con il pacchetto azure-ai-ml versione 1.5.0 o successiva installato.
Se si dispone di un pacchetto SDK precedente, usare il codice seguente per disinstallarlo e installarlo nuovo.
pip uninstall azure-ai-ml
pip install azure-ai-ml
pip show azure-ai-ml 1.5.0
Creare una connessione dati Snowflake
È possibile usare l'interfaccia della riga di comando di Azure Machine Learning, Azure Machine Learning SDK per Python o Machine Learning Studio per creare una connessione dati Snowflake che usa l'autenticazione con nome utente/password.
È anche possibile usare interfaccia della riga di comando di Azure o Python SDK per creare una connessione Snowflake che usa OAuth con un'entità servizio. Machine Learning Studio non supporta la creazione di connessioni OAuth.
Creare una connessione che usa l'autenticazione con nome utente/password
Per creare la connessione Snowflake, assemblare prima un file YAML che definisce la connessione e quindi eseguire un comando o uno script che chiama il file YAML. Per Python SDK, è anche possibile specificare le informazioni di connessione direttamente senza usare un file YAML.
È possibile archiviare le credenziali nel file YAML ed eseguire l'override delle credenziali archiviate nella riga di comando interfaccia della riga di comando di Azure quando si crea la connessione. Tuttavia, è consigliabile evitare di archiviare le credenziali in un file, perché una violazione della sicurezza potrebbe causare una perdita di credenziali. È invece possibile lasciare vuoti i credentials valori e specificarli nella riga di comando.
Il file YAML seguente definisce una connessione Snowflake che usa l'autenticazione con nome utente/password. Per creare il file, specificare un <connection-name> e sostituire i segnaposto <account>, <database>, <warehouse> e <role> con i valori dal tuo account Snowflake. Se non si specifica un , <role>il valore predefinito è PUBLIC. Salvare il file con un nome come my_snowflake_connection.yaml.
$schema: http://azureml/sdk-2-0/Connection.json
type: snowflake
name: <connection-name>
target: jdbc:snowflake://<account>.snowflakecomputing.com/?db=<database>&warehouse=<warehouse>&role=<role>
credentials:
type: username_password
username: <snowflake-username>
password: <snowflake-password>
È possibile creare una connessione dati a un database Snowflake in Machine Learning Studio e usare la connessione per eseguire processi di importazione dati. Le credenziali di nome utente/password sono memorizzate in modo sicuro nell'archivio chiavi associato all'area di lavoro.
Per creare una connessione dati in studio di Azure Machine Learning:
Nell'area di lavoro Machine Learning selezionare Data in Assets nel menu di spostamento a sinistra.
Nella pagina Dati selezionare la scheda Connessioni dati e quindi selezionare Connetti.
Per creare la connessione, eseguire una delle righe di comando seguenti, specificando il nome file YAML per il <yaml-filename> segnaposto.
Per usare il nome utente e la password archiviati nel file YAML, eseguire il comando seguente:
az ml connection create --file <yaml-filename>.yaml
Per fornire il nome utente e la password come parte della riga di comando, eseguire il comando seguente, immettendo <username> e <password> per i segnaposto:
az ml connection create --file <yaml-filename>.yaml --set credentials.username="<username>" credentials.password="<password>"
Per creare la connessione Snowflake chiamando il file YAML, eseguire lo script di Python seguente, sostituendo il segnaposto <yaml-filename> con il nome file YAML.
from azure.ai.ml import MLClient, load_workspace_connection
ml_client = MLClient.from_config()
wps_connection = load_workspace_connection(source="./<yaml-filename>.yaml")
wps_connection.credentials.username="<snowflake-username>"
wps_connection.credentials.password="<snowflake-password>"
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Creare direttamente
Per specificare direttamente le informazioni di connessione senza usare un file YAML, eseguire lo script di Python seguente. Fornire un <connection-name> e sostituire i segnaposto <account>, <database>, <warehouse> e <role> con i valori del tuo account Snowflake.
Se non si specifica un , <role>il valore predefinito è PUBLIC. Per il tipo di autenticazione username-password, i valori nome/password devono essere codificati con URL.
from azure.ai.ml import MLClient
from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import UsernamePasswordConfiguration
import urllib.parse
username = urllib.parse.quote(os.environ["SNOWFLAKEDB_USERNAME"], safe="")
password = urllib.parse.quote(os.environ["SNOWFLAKEDB_PASSWORD"], safe="")
target= "jdbc:snowflake://<account>.snowflakecomputing.com/?db=<database>&warehouse=<warehouse>&role=<role>"
name= <connection-name>
wps_connection = WorkspaceConnection(name= name,
type="snowflake",
target= target,
credentials= UsernamePasswordConfiguration(username=username, password=password)
)
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Nella schermata Crea connessione completare le informazioni seguenti:
-
Servizio: selezionare Snowflake.
-
Destinazione: immettere la destinazione seguente, usando i valori dell'account Snowflake per i segnaposto:
jdbc:snowflake://<account>.snowflakecomputing.com/?db=<database>&warehouse=<warehouse>&role=<ruolo>
-
Tipo di autenticazione: selezionare Username password (Password nome utente).
-
Nome utente: immettere il nome utente snowflake.
-
Password: Inserisci la password di Snowflake.
-
Nome connessione: immettere un nome per la connessione Snowflake.
Facoltativamente, selezionare Test connessione per testare la connessione e quindi selezionare Salva.
Usare interfaccia della riga di comando di Azure o Python SDK per creare una connessione con l'autenticazione OAuth
È possibile usare interfaccia della riga di comando di Azure o Python SDK per creare una connessione Snowflake che utilizza un service principal per l'autenticazione OAuth.
Per creare una connessione OAuth per Azure Machine Learning, sono necessarie le informazioni seguenti:
-
ID client: ID del principale del servizio
-
Segreto client: segreto dell'entità servizio
- ID Tenant: ID del tenant Microsoft Entra ID
Per creare la connessione, assemblare prima un file YAML che definisce la connessione e quindi eseguire un comando o uno script che chiama il file YAML. Per Python SDK, è anche possibile specificare le informazioni di connessione direttamente senza usare un file YAML.
Creare il file YAML seguente per definire una connessione Snowflake che usa OAuth. Fornire un <connection-name> e sostituire i segnaposto <account>, <database>, <warehouse>, e <service-principal-scope> con i valori del proprio account Snowflake. Per le credenziali, specificare <client-id>, <client-secret>e <tenant_id>.
name: <connection-name>
type: snowflake
target: jdbc:snowflake://<account>.snowflakecomputing.com/?db=<database>&warehouse=<warehouse>&scope=<service-principal-scope>
credentials:
type: service_principal
client_id: <client-id>
client_secret: <client-secret>
tenant_id: <tenant-id>
Machine Learning Studio non supporta la creazione di connessioni dati che usano l'autenticazione OAuth.
Per creare la connessione usando le informazioni sulle credenziali archiviate nel file YAML, eseguire il comando seguente, sostituendo il segnaposto con il <yaml-filename> nome file YAML.
az ml connection create --file <yaml-filename>.yaml
Per eseguire l'override delle informazioni sulle credenziali nel file YAML o fornire le credenziali nella riga di comando, eseguire il seguente comando, immettendo i valori <client-id>, <client-secret> e <tenant-id> per i segnaposto:
az ml connection create --file <yaml-filename>.yaml --set credentials.client_id="<client-id>" credentials.client_secret="<client-secret>" credentials.tenant_id="<tenant-id>"
Per creare la connessione OAuth chiamando il file YAML, eseguire lo script di Python seguente, sostituendo il segnaposto <yaml-filename> con il nome file YAML. Facoltativamente, è possibile specificare o sostituire i <wps_connection.credentials> valori.
from azure.ai.ml import MLClient, load_workspace_connection
ml_client = MLClient.from_config()
wps_connection = load_workspace_connection(source="./<yaml-filename>.yaml")
wps_connection.credentials.client_id="<client-id>"
wps_connection.credentials.client_secret="<client-secret>"
wps_connection.credentials.tenant_id="<tenant-id>"
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Creare direttamente
Eseguire lo script di Python seguente per specificare direttamente le informazioni di connessione OAuth senza usare un file YAML. Fornire un <connection-name>, e sostituire i <account>, <database>, <warehouse> e <role> con i valori dell'account Snowflake. Immettere <client-id>, <client-secret> e <tenant-id> nei segnaposto corrispondenti.
from azure.ai.ml import MLClient
from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import ServicePrincipalConfiguration
target= "jdbc:snowflake://<account>.snowflakecomputing.com/?db=<database>&warehouse=<warehouse>&role=<role>"
name= <connection-name>
auth = ServicePrincipalConfiguration(client_id="<client-id>", client_secret="<client-secret>", tenant_id="<tenant-id>")
wps_connection = WorkspaceConnection(name= name,
type="snowflake",
target=target,
credentials=auth
)
ml_client.connections.create_or_update(workspace_connection=wps_connection)
È possibile creare una connessione Snowflake con l'autenticazione con nome utente/password oppure usare interfaccia della riga di comando di Azure o Python SDK per creare la connessione con l'autenticazione OAuth.
Creare una connessione dati per database SQL di Azure
È possibile usare l'interfaccia della riga di comando di Azure Machine Learning, Azure Machine Learning SDK per Python o Machine Learning Studio per creare una connessione dati database SQL di Azure.
Per creare una connessione di database Azure SQL, assemblare prima un file YAML che definisce la connessione e quindi eseguire un comando o uno script Python SDK interfaccia della riga di comando di Azure che chiama il file YAML. Per Python SDK, è anche possibile specificare le informazioni di connessione direttamente senza usare un file YAML.
Creare il file YAML seguente per definire la connessione database SQL di Azure e salvare il file con un nome come my_azuresqldb_connection.yaml. Specificare un <connection-name> e sostituire i segnaposto <server>, <port> e <database> con i valori appropriati del database Azure SQL.
Per credentials, è possibile archiviare il nome utente e la password del database Azure SQL in questo file, ma è più sicuro lasciare vuoti i valori e specificarli nella riga di comando che crea la connessione.
$schema: http://azureml/sdk-2-0/Connection.json
type: azure_sql_db
name: <connection-name>
target: Server=tcp:<server>,<port>;Database=<database>;Trusted_Connection=False;Encrypt=True;Connection Timeout=30
credentials:
type: sql_auth
username: <username>
password: <password>
È possibile creare una connessione dati a un database Azure SQL in Machine Learning Studio e usare la connessione per eseguire processi di importazione dati. Le credenziali di nome utente/password sono archiviate in modo sicuro nell'archivio chiavi associato all'area di lavoro.
Per creare una connessione dati in studio di Azure Machine Learning:
Nell'area di lavoro Machine Learning selezionare Data in Assets nel menu di spostamento a sinistra.
Nella pagina Dati selezionare la scheda Connessioni dati e quindi selezionare Connetti.
Per creare la connessione, eseguire una delle seguenti righe di comando CLI, specificando il nome del file YAML per il segnaposto <yaml-filename>.
Per usare il nome utente e la password archiviati nel file YAML, eseguire il comando seguente:
az ml connection create --file <yaml-filename>.yaml
Per fornire il nome utente e la password come parte della riga di comando, eseguire il comando seguente, immettendo <username> e <password> per i segnaposto:
az ml connection create --file <yaml-filename>.yaml --set credentials.username="<username>" credentials.password="<password>"
Per creare la connessione database SQL di Azure chiamando il file YAML, eseguire lo script di Python seguente, sostituendo il segnaposto <yaml-filename> con il nome file YAML.
from azure.ai.ml import MLClient, load_workspace_connection
ml_client = MLClient.from_config()
wps_connection = load_workspace_connection(source="./<yaml-filename>.yaml")
wps_connection.credentials.username="<username>"
wps_connection.credentials.password="<password>"
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Creare direttamente
Per specificare direttamente le informazioni di connessione senza usare un file YAML, eseguire lo script di Python seguente. Specificare un <connection-name> e sostituire i segnaposto <server>, <port> e <database> con i valori per il database Azure SQL. Per il tipo di autenticazione username-password, i valori nome e password devono essere codificati con URL.
from azure.ai.ml import MLClient
from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import UsernamePasswordConfiguration
import urllib.parse
username = urllib.parse.quote(os.environ["MYSQL_USERNAME"], safe="")
password = urllib.parse.quote(os.environ["MYSQL_PASSWORD"], safe="")
target= "Server=tcp:<server>,<port>;Database=<database>;Trusted_Connection=False;Encrypt=True;Connection Timeout=30"
# add the sql servername, port address and database
name= <connection-name>
wps_connection = WorkspaceConnection(name= name,
type="azure_sql_db",
target= target,
credentials= UsernamePasswordConfiguration(username=username, password=password)
)
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Nella schermata Crea connessione completare le informazioni seguenti:
-
Servizio: selezionare AzureSqlDb.
-
Target: immettere la destinazione seguente usando i valori del database Azure SQL per i segnaposto:
Server=tcp:<server>,<port>;Database=<database>;Trusted_Connection=False;Encrypt=True;Connection Timeout=30
-
Tipo di autenticazione: selezionare Username password (Password nome utente).
-
Nomeutente: immettere il nome utente database SQL di Azure.
-
Password: immettere la password database SQL di Azure.
-
Nome connessione: immettere un nome per la connessione database SQL di Azure.
Facoltativamente, selezionare Test connessione per testare la connessione e quindi selezionare Salva.
Creare una connessione dati Amazon S3
È possibile usare l'interfaccia della riga di comando di Azure Machine Learning, Azure Machine Learning SDK per Python o Machine Learning Studio per creare una connessione dati Amazon S3.
Per creare una connessione dati Amazon S3, assemblare prima un file YAML che definisce la connessione e quindi eseguire un comando o uno script interfaccia della riga di comando di Azure o Python SDK che chiama il file YAML. Per Python SDK, è anche possibile specificare le informazioni di connessione direttamente senza usare un file YAML.
Per usare l'interfaccia della riga di comando di Azure Machine Learning per creare una connessione dati Amazon S3, assemblare prima un file YAML che definisce la connessione e quindi eseguire un comando interfaccia della riga di comando di Azure che chiama il file YAML.
Creare il file YAML seguente che definisce la connessione Amazon S3. Fornisci un <connection-name> e sostituisci i segnaposto <s3-bucket-name>, <access-key-id> e <secret-access-key> con i valori del tuo account Amazon S3. Salvare il file con un nome come my_amazons3_connection.yaml.
$schema: http://azureml/sdk-2-0/Connection.json
type: s3
name: <connection-name>
target: <s3-bucket-name>
credentials:
type: access_key
access_key_id: <access-key-id>
secret_access_key: <secret-access-key>
È possibile creare una connessione ai dati di Amazon S3 in Machine Learning Studio e usare la connessione per eseguire i processi di importazione dei dati. Le credenziali nome utente/password vengono archiviate in modo sicuro nell'archivio chiavi associato all'area di lavoro.
Per creare una connessione dati in studio di Azure Machine Learning:
Nell'area di lavoro Machine Learning selezionare Data in Assets nel menu di spostamento a sinistra.
Nella pagina Dati selezionare la scheda Connessioni dati e quindi selezionare Connetti.
Per creare la connessione, eseguire il comando dell'interfaccia della riga di comando seguente, specificando il nome del file YAML per il segnaposto <yaml-filename>.
az ml connection create --file <yaml-filename>.yaml
Per creare la connessione Amazon S3 chiamando il file YAML, eseguire lo script di Python seguente, sostituendo il segnaposto <yaml-filename> con il nome file YAML.
from azure.ai.ml import MLClient, load_workspace_connection
ml_client = MLClient.from_config()
wps_connection = load_workspace_connection(source="./<yaml-filename>.yaml")
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Creare direttamente
Per specificare le informazioni di connessione direttamente senza usare un file YAML, eseguire lo script di Python seguente. Specificare un <connection-name> e sostituire i segnaposto <s3-bucket-name>, <access-key-id> e <secret-access-key> con i valori per l'account Amazon S3.
from azure.ai.ml import MLClient
from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import AccessKeyConfiguration
target=<s3-bucket-name>
name=<connection-name>
wps_connection=WorkspaceConnection(name=name,
type="s3",
target= target,
credentials= AccessKeyConfiguration(access_key_id="<access-key-id>",secret_access_key="<secret-access-key>")
)
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Nella schermata Crea connessione completare le informazioni seguenti:
-
Servizio: selezionare S3.
-
Destinazione: immettere il nome del bucket Amazon S3.
-
Tipo di autenticazione: selezionare Chiave di accesso.
-
ID chiave di accesso: immettere l'ID chiave di accesso amazon S3.
-
Chiave di accesso segreto: immettere la chiave di accesso privata Amazon S3.
-
Nome connessione: immettere un nome per la connessione Amazon S3.
Facoltativamente, selezionare Test connessione per testare la connessione e quindi selezionare Salva.
Creare connessioni esterne prive di dati
È anche possibile creare connessioni di Azure Machine Learning non relative ai dati a servizi esterni utilizzati nel proprio codice. Questa sezione illustra come creare le connessioni non dati seguenti:
- Git
- feed Python
- Registro Azure Container
- Registro contenitori generico
- Chiave API
Creare una connessione Git
È possibile creare una connessione Git usando interfaccia della riga di comando di Azure, Python SDK o Machine Learning Studio.
Per creare una connessione Git usando interfaccia della riga di comando di Azure, definire la connessione usando uno dei file YAML seguenti. Denominare il file come git-connection.yml.
Per connettersi usando un token di accesso personale (PAT), fornire un <connection-name> e sostituire i segnaposto <account>, <repo> e <PAT> con i valori per l'account Git, il repository e il PAT.
name: <connection-name>
type: git
target: https://github.com/<account>/<repo>
credentials:
type: pat
pat: <PAT>
Per connettersi a un repository pubblico senza usare le credenziali, fornire un <connection-name> e sostituire i segnaposto <account> e <repo> con i propri valori.
name: <connection-name>
type: git
target: https://github.com/<account>/<repo>
Creare la connessione Azure Machine Learning eseguendo il comando seguente, specificando il nome file YAML per il segnaposto <yaml-filename>.
az ml connection create --file <yaml-filename>.yaml
Per creare una connessione a un repository Git usando Python SDK, usare lo script seguente. Per autenticare la connessione, usare un token di accesso personale (PAT) GitHub. Specificare un <connection-name>, e sostituire i segnaposto <account>, <repo> e <PAT> con i tuoi valori.
from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import UsernamePasswordConfiguration, PatTokenConfiguration
name = "<connection-name>"
target = "https://github.com/<account>/<repo>"
wps_connection = WorkspaceConnection(
name=name,
type="git",
target=target,
credentials=PatTokenConfiguration(pat="<PAT>"),
)
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Per creare una connessione Git in Machine Learning Studio:
In studio di Azure Machine Learning selezionare Connections in Manage nel riquadro di spostamento a sinistra e quindi selezionare Connect.
Nella schermata Aggiungi una connessione ad asset esterni scorrere verso il basso fino ad Altri tipi di risorse e selezionare Git.
Nella schermata Connetti un repository Git immettere il percorso del repository Git in Endpoint e il token di accesso personale Git (PAT) in Token di accesso personale. Specificare un nome di connessione e quindi selezionare Aggiungi connessione.
feed Python
È possibile creare una connessione a un feed di Python usando interfaccia della riga di comando di Azure, Python SDK o Machine Learning Studio.
Definire una connessione Python feed usando uno dei file YAML seguenti. Denominare il file come python-feed-connection.yml.
Per connettersi usando un token di accesso personale, specificare un <connection-name> e sostituire i segnaposto <feed-url> e <PAT> con i valori per il feed.
name: <connection-name>
type: python_feed
target: https://<feed-url>
credentials:
type: pat
pat: <PAT>
Per connettersi usando un nome utente e una password, fornire un <connection-name> e sostituire i segnaposto <feed-url>, <username> e <password> con i valori per il feed.
name: <connection-name>
type: python_feed
target: https://<feed-url>
credentials:
type: username_password
username: <username>
password: <password>
Per connettersi a un feed pubblico senza usare le credenziali, specificare un <connection-name> e sostituire il segnaposto <feed-url> con l'URL del feed Python.
name: <connection-name>
type: python_feed
target: https://<feed-url>
Creare la connessione Azure Machine Learning eseguendo il comando seguente, specificando il nome file YAML per il segnaposto <yaml-filename>.
az ml connection create --file <yaml-filename>.yaml
Usare lo script seguente per creare una connessione Python feed usando Python SDK. Specificare un <connection-name> e sostituire il segnaposto <feed-url> con l'URL del feed Python.
È possibile usare un pat o un nome utente e una password per autenticare la connessione o connettersi a un feed pubblico senza credenziali. Per il tipo di autenticazione con token di accesso personale, specificare il token per il segnaposto <PAT>. Per il tipo di autenticazione username-password, i valori nome/password devono essere codificati con URL.
Per usare nome utente/password o nessuna autenticazione anziché il token di accesso personale, rimuovere il commento dalla riga o dalle righe appropriate nello script seguente e impostare come commento la riga credentials=PatTokenConfiguration(pat="<PAT>"),.
from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import UsernamePasswordConfiguration, PatTokenConfiguration
# import urllib.parse
# username = urllib.parse.quote(os.environ["FEED_USERNAME"], safe="")
# password = urllib.parse.quote(os.environ["FEED_PASSWORD"], safe="")
name = "<connection-name>"
target = "https://<feed-url>"
wps_connection = WorkspaceConnection(
name=name,
type="python_feed",
target=target,
#credentials=UsernamePasswordConfiguration(username=username, password=password),
credentials=PatTokenConfiguration(pat="<PAT>"),
#credentials=None
)
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Per creare una connessione a un feed di Python in Machine Learning Studio:
Nell'area di lavoro studio di Azure Machine Learning selezionare Connections in Manage nel riquadro di spostamento sinistro e quindi selezionare Connect.
Nella schermata Aggiungi una connessione ad asset esterni scorrere verso il basso fino a Other resource types e selezionare Python feed.
Nella schermata Connettere un feed di Python:
- Immettere il percorso del repository Git in Endpoint.
-
Selezionare Nessuno, PAT o Password utente per Autenticazione e specificare i valori appropriati.
- Specificare un nome di connessione.
Selezionare Aggiungi connessione.
Registro Azure Container
È possibile creare una connessione a Registro Azure Container usando interfaccia della riga di comando di Azure, Python SDK o Machine Learning Studio.
Usare il file YAML seguente per definire una connessione a Registro Azure Container con l'autenticazione con nome utente/password.
name: <connection-name>
type: container_registry
target: https://<container-registry-url>
credentials:
type: username_password
username: <username>
password: <password>
Per creare la connessione, eseguire il comando seguente:
az ml connection create --file connection.yaml
L'esempio seguente crea una connessione Registro Azure Container:
from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import UsernamePasswordConfiguration
# If using username/password, the name/password values should be url-encoded
import urllib.parse
username = os.environ["REGISTRY_USERNAME"]
password = os.environ["REGISTRY_PASSWORD"]
name = "my_acr_conn"
target = "https://iJ5kL6mN7.core.windows.net/mycontainer"
wps_connection = WorkspaceConnection(
name=name,
type="container_registry",
target=target,
credentials=UsernamePasswordConfiguration(username=username, password=password),
)
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Per creare una connessione a Registro Azure Container in Machine Learning Studio:
Nell'area di lavoro Azure Machine Learning selezionare Connections in Manage nel riquadro di spostamento sinistro e quindi selezionare Connect.
Nella schermata Aggiungi una connessione ad asset esterni scorrere verso il basso fino ad Altri tipi di risorse e selezionare Registro Contenitori.
Immettere il percorso del registro contenitori Azure in Endpoint, selezionare None o Username password per Autenticazione con i valori appropriati e immettere un Nome della connessione.
Selezionare Aggiungi connessione.
Registro Contenitori generici
La connessione all'area di lavoro GenericContainerRegistry specifica un registro esterno, ad esempio Nexus o Artifactory, per le compilazioni di immagini. Le immagini dell'ambiente vengono inviate dal registro specificato e la cache precedente viene ignorata. È possibile creare una connessione a un registro contenitori generico usando interfaccia della riga di comando di Azure, Python SDK o Machine Learning Studio.
Per interfaccia della riga di comando di Azure e Python SDK, i file YAML di esempio seguenti definiscono una connessione generica al registro contenitori. Aggiornare i valori di esempio con i propri valori.
#myenv.yml
$schema: https://azuremlschemas.azureedge.net/latest/environment.schema.json
name: docker-image-plus-conda-example
image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04
type: python_feed
conda_file: conda_dep.yml
description: Environment created from a Docker image plus Conda environment
#conda_dep.yml
name: project_environment
dependencies:
- python=3.10
- pip:
- azureml-defaults
channels:
- anaconda
- conda-forge
#connection.yml
name: ws_conn_generic_container_registry
type: container_registry
target: https://test-registry.com
credentials:
type: username_password
username: myusername
password: <password>
#hello_world_job.yml
$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment: azureml:myenv@latest
È anche possibile creare una connessione Registro Container generico (anteprima) in Studio.
In studio di Azure Machine Learning selezionare Connections in Manage nel riquadro di spostamento a sinistra e quindi selezionare Connect.
Nella schermata Aggiungi una connessione ad asset esterni selezionare Registro Contenitori generici (ANTEPRIMA) in Altri tipi di risorse.
Eseguire il comando seguente per creare la connessione usando i file YAML precedenti e le credenziali. Aggiornare i valori di esempio con i propri valori.
az ml connection create --file connection.yml --credentials username=myusername password=<password> --resource-group my-resource-group --workspace-name my-workspace
Per creare l'ambiente, eseguire il comando seguente:
az ml environment create --name docker-image-plus-conda-example --version 1 --file myenv.yml --conda-file conda_dep.yml --image mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04 --resource-group my-resource-group --workspace-name my-workspace
Eseguire il comando seguente per verificare che l'ambiente sia stato creato correttamente.
az ml environment show --name docker-image-plus-conda-example --version 1 --resource-group my-resource-group --workspace-name my-workspace
Lo script di esempio seguente Python crea una connessione Generic Container Registry usando i file di esempio precedenti. Aggiornare i valori di esempio con i propri valori.
import os
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
from azure.ai.ml.entities import Environment
from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import UsernamePasswordConfiguration
from azureml.core.conda_dependencies import CondaDependencies
from azure.ai.ml import command
username = os.environ["REGISTRY_USERNAME"]
password = os.environ["REGISTRY_PASSWORD"]
# Enter details of Azure Machine Learning workspace
subscription_id = "00000000-0000-0000-0000-000000000000"
resource_group = "my-resource-group"
workspace = "my-workspace"
ml_client = MLClient( DefaultAzureCredential(), subscription_id, resource_group, workspace)
credentials = UsernamePasswordConfiguration(username=username, password=password)
# Create GenericContainerRegistry workspace connection for a generic registry
ws_connection = WorkspaceConnection(name="ws_conn_generic_container_registry", target="https://test-registry.com", type="GenericContainerRegistry", credentials=credentials)
ml_client.connections.create_or_update(ws_connection)
# Create an environment
env_docker_conda = Environment(image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04", conda_file="conda_dep.yml", name="docker-image-plus-conda-example", description="Environment created from a Docker image plus Conda environment.")
ml_client.environments.create_or_update(env_docker_conda)
job = command(command="echo 'hello world'", environment=env_docker_conda,display_name="v2-job-example")
returned_job = ml_client.create_or_update(job)
Nella schermata Connetti un registro contenitori :
- Immettere il percorso del registro contenitori in Endpoint.
- Immettere il nome utente e la password.
- Specificare un nome di connessione.
Selezionare Aggiungi connessione.
Chiave API
Creare il file YAML seguente per definire una connessione a una chiave API. Aggiornare i valori di esempio con i propri valori.
name: my_api_key
type: api_key
api_base: "https://myapi.core.windows.net/mycontainer"
api_key: "aAbBcCdD"
Per creare la connessione, eseguire il comando seguente:
az ml connection create --file connection.yaml
Per una maggiore sicurezza, lasciare il api_key valore fuori dal file YAML e specificarlo nella riga di comando:
az ml connection create --file connection.yml --set api_key="aAbBcCdD"
L'esempio di SDK di Python seguente crea una connessione con chiave API. Aggiornare i valori di esempio con i propri valori.
from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import UsernamePasswordConfiguration, ApiKeyConfiguration
name = "my_api_key"
target = "https://myapi.core.windows.net/mycontainer"
wps_connection = WorkspaceConnection(
name=name,
type="apikey",
target=target,
credentials=ApiKeyConfiguration(key="aAbBcCdD"),
)
ml_client.connections.create_or_update(workspace_connection=wps_connection)
Per creare una connessione a una chiave API in Machine Learning Studio:
Nell'area di lavoro Azure Machine Learning selezionare Connections in Manage nel riquadro di spostamento sinistro e quindi selezionare Connect.
Nella schermata Aggiungi una connessione ad asset esterni scorrere verso il basso fino ad Altri tipi di risorse e selezionare Chiave API.
Immettere il percorso della chiave API in Endpoint, immettere il segreto della chiave API in Chiave, immettere un nome di connessione e quindi selezionare Aggiungi connessione.
Contenuto correlato