Esporta (0) Stampa
Espandi tutto

Connessione a Servizi multimediali con Media Services SDK per .NET

Aggiornamento: ottobre 2014

Questo argomento descrive come ottenere una connessione a Servizi multimediali di Microsoft Azure a livello di codice quando si programma con Servizi multimediali SDK per .NET.

In particolare, vengono trattati i seguenti argomenti:

Per connettersi a Servizi multimediali a livello di codice, è necessario prima definire un account di Azure, configurare Servizi multimediali su tale account e quindi impostare un progetto di Visual Studio per lo sviluppo con Servizi multimediali SDK per .NET. Per altre informazioni, vedere Configurazione per lo sviluppo con l'SDK di Servizi multimediali per .NET.

Al termine del processo di impostazione dell'account di Servizi multimediali si ottengono i seguenti valori di connessione necessari. Usare questi valori per impostare connessioni a Servizi multimediali a livello di codice.

  • Nome dell'account di Servizi multimediali.

  • Chiave dell'account di Servizi multimediali.

noteNota
Per trovare questi valori, accedere al portale Azure, selezionare il proprio account di Servizi multimediali e fare clic sull'icona "GESTISCI CHIAVI" nella parte inferiore della finestra del portale. Facendo clic sull'icona accanto a ciascuna casella di testo, il valore viene copiato negli Appunti di sistema.

Per poter iniziare la programmazione basata su Servizi multimediali è necessario prima creare un'istanza di CloudMediaContext che rappresenti il contesto del server. CloudMediaContext contiene riferimenti a raccolte importanti composte da processi, asset, file, criteri di accesso e localizzatori.

noteNota
La classe CloudMediaContext non è di tipo thread safe. È quindi necessario creare un nuovo CloudMediaContext per ciascun thread o set di operazioni.

CloudMediaContext include cinque overload del costruttore. Si consiglia di usare costruttori che accettano MediaServicesCredentials come parametro. Per altre informazioni, vedere Riutilizzo di token del Servizio di controllo di accesso. L'esempio seguente usa il costruttore public CloudMediaContext(MediaServicesCredentials credentials). :

// _cachedCredentials and _context are class member variables. 
_cachedCredentials = new MediaServicesCredentials(
                _mediaServicesAccountName,
                _mediaServicesAccountKey);

_context = new CloudMediaContext(_cachedCredentials);

L'elenco seguente descrive i costruttori di CloudMediaContext.

  • L'overload seguente inizializza una nuova istanza della classe CloudMediaContext con il nome e la chiave dell'account di Servizi multimediali di Microsoft Azure specificati tramite i quali eseguire l'autenticazione.

    public CloudMediaContext(string accountName, string accountKey)
    
  • L'overload seguente inizializza una nuova istanza della classe CloudMediaContext con le credenziali di Servizi multimediali di Microsoft Azure specificate. Questo overload è stato aggiunto in Media Services Client SDK versione 3.0.0.0.

    public CloudMediaContext(MediaServicesCredentials credentials)
    
  • L'overload seguente inizializza una nuova istanza della classe CloudMediaContext con l'endpoint di Servizi multimediali di Microsoft Azure e le credenziali di Servizi multimediali specificati. Questo overload è stato aggiunto in Media Services Client SDK versione 3.0.0.0.

    public CloudMediaContext(Uri apiServer, MediaServicesCredentials credentials)
    
  • L'overload seguente inizializza una nuova istanza della classe CloudMediaContext con l'endpoint nonché il nome e la chiave dell'account di Servizi multimediali di Microsoft Azure specificati tramite i quali eseguire l'autenticazione.

    public CloudMediaContext(Uri apiServer, string accountName, string accountKey)
    
  • L'overload seguente inizializza una nuova istanza della classe CloudMediaContext che accetta i seguenti parametri: endpoint nonché nome e chiave dell'account di Servizi multimediali tramite i quali eseguire l'autenticazione, ambito di autorizzazione ed endpoint del Servizio di controllo di accesso con cui eseguire l'autenticazione.

    public CloudMediaContext(Uri apiServer, string accountName, string accountKey, string scope, string acsBaseAddress)
    

L'esempio seguente crea una nuova istanza di CloudMediaContext e passa i valori di stringa del nome e della chiave dell'account di Servizi multimediali.

CloudMediaContext context = new CloudMediaContext(MediaServicesAccountName, MediaServicesAccountKey);

La sezione seguente mostra come riusare token del Servizio di controllo di accesso mediante costruttori di CloudMediaContext che accettano MediaServicesCredentials come parametro.

Azure Active Directory Access Control (noto anche come Servizio di controllo di accesso o ACS) è un servizio basato sul cloud che semplifica l'autenticazione e l'autorizzazione degli utenti per l'accesso alle rispettive applicazioni Web. Servizi multimediali di Microsoft Azure controlla l'accesso ai propri servizi mediante il protocollo OAuth che richiede un token ACS. Servizi multimediali riceve questi token da un server di autorizzazione.

Se per sviluppare si usa Servizi multimediali SDK, è possibile scegliere di gestire i token in modo automatico tramite il codice dell'SDK. L'intera gestione dei token ACS da parte dell'SDK genera tuttavia richieste di token non necessarie, che determinano un significativo impiego di tempo e di risorse client e server. Se la velocità è troppo elevata, inoltre, il server ACS pone un limite di 30 richieste al secondo. Per altre informazioni, vedere Limitazioni del servizio ACS.

A partire da Media Services SDK versione 3.0.0.0 è possibile riusare i token ACS. I costruttori di CloudMediaContext che accettano MediaServicesCredentials come parametro permettono di condividere i token ACS in più contesti. La classe MediaServicesCredentials incapsula le credenziali di Servizi multimediali. Se è disponibile un token ACS, la cui scadenza è nota, è possibile creare una nuova istanza di MediaServicesCredentials con quel token e passarla al costruttore di CloudMediaContext. Tenere presente che, al momento della scadenza, i token vengono automaticamente aggiornati da Servizi multimediali. È possibile riusare i token ACS in due modi diversi, come illustrato nell'esempio seguente.

  • È possibile memorizzare nella cache l'oggetto MediaServicesCredentials, ad esempio in una variabile di classe statica, e passare l'oggetto memorizzato al costruttore di CloudMediaContext. L'oggetto MediaServicesCredentials contiene un token ACS che può essere riusato, se ancora valido. Se il token non è più valido, verrà aggiornato da Servizi multimediali SDK tramite le credenziali fornite al costruttore di MediaServicesCredentials.

    Tenere presente che l'oggetto MediaServicesCredentials ottiene un token valido solo dopo la chiamata a RefreshToken. CloudMediaContext chiama il metodo RefreshToken nel costruttore. Se si intende salvare i valori del token in una risorsa di archiviazione esterna, assicurarsi di verificare che il valore di TokenExpiration sia ancora valido prima di salvare i dati del token. In caso contrario, chiamare RefreshToken prima della memorizzazione nella cache.

    // Create and cache the Media Services credentials in a static class variable.
    _cachedCredentials = new MediaServicesCredentials(_mediaServicesAccountName, _mediaServicesAccountKey);
    
    


    // Use the cached credentials to create a new CloudMediaContext object.
    if(_cachedCredentials == null)
    {
        _cachedCredentials = new MediaServicesCredentials(_mediaServicesAccountName, _mediaServicesAccountKey);
    }
    
    CloudMediaContext context = new CloudMediaContext(_cachedCredentials);
    
  • È possibile memorizzare nella cache anche la stringa AccessToken e i valori di TokenExpiration. Questi ultimi potranno essere usati in un secondo momento per creare un oggetto MediaServicesCredentials con i dati del token memorizzati nella cache. Questa funzionalità è particolarmente utile negli scenari in cui il token può essere condiviso in modo sicuro tra più processi o computer.

    Il seguente frammento di codice chiama i metodi SaveTokenDataToExternalStorage, GetTokenDataFromExternalStorage e UpdateTokenDataInExternalStorageIfNeeded non definiti nel presente esempio. È possibile definire questi metodi per archiviare, recuperare e aggiornare i dati del token in una risorsa di archiviazione esterna.

    
    CloudMediaContext context1 = new CloudMediaContext(_mediaServicesAccountName, _mediaServicesAccountKey);
    
    // Get token values from the context.
    var accessToken = context1.Credentials.AccessToken;
    var tokenExpiration = context1.Credentials.TokenExpiration;
    
    // Save token values for later use. 
    // The SaveTokenDataToExternalStorage method should check 
    // whether the TokenExpiration value is valid before saving the token data. 
    // If it is not valid, call MediaServicesCredentials’s RefreshToken before caching.
    SaveTokenDataToExternalStorage(accessToken, tokenExpiration);
    
    
    Usare i valori del token salvati per creare MediaServicesCredentials.

    var accessToken = "";
    var tokenExpiration = DateTime.UtcNow;
    
    // Retrieve saved token values.
    GetTokenDataFromExternalStorage(out accessToken, out tokenExpiration);
    
    // Create a new MediaServicesCredentials object using saved token values.
    MediaServicesCredentials credentials = new MediaServicesCredentials(_mediaServicesAccountName, _mediaServicesAccountKey)
    {
        AccessToken = accessToken,
        TokenExpiration = tokenExpiration
    };
    
    CloudMediaContext context2 = new CloudMediaContext(credentials);
    
    Aggiornare la copia del token nel caso in cui sia stato aggiornato da Media Services SDK.

    if(tokenExpiration != context2.Credentials.TokenExpiration)
    {
        UpdateTokenDataInExternalStorageIfNeeded(accessToken, context2.Credentials.TokenExpiration);
    }
    
    
  • Se si dispone di più account di Servizi multimediali, ad esempio a scopo di condivisione del carico o di distribuzione geografica, è possibile memorizzare nella cache oggetti MediaServicesCredentials usando la raccolta System.Collections.Concurrent.ConcurrentDictionary (ConcurrentDictionary rappresenta una raccolta thread-safe di coppie chiave/valore a cui possono accedere più thread contemporaneamente). È quindi possibile usare il metodo GetOrAdd per ottenere le credenziali memorizzate nella cache.

    // Declare a static class variable of the ConcurrentDictionary type in which the Media Services credentials will be cached.  
    private static readonly ConcurrentDictionary<string, MediaServicesCredentials> mediaServicesCredentialsCache = 
        new ConcurrentDictionary<string, MediaServicesCredentials>();
    
    // Cache (or get already cached) Media Services credentials. Use these credentials to create a new CloudMediaContext object.
    static public CloudMediaContext CreateMediaServicesContext(string accountName, string accountKey)
    {
        CloudMediaContext cloudMediaContext;
        MediaServicesCredentials mediaServicesCredentials;
    
        mediaServicesCredentials = mediaServicesCredentialsCache.GetOrAdd(
            accountName,
            valueFactory => new MediaServicesCredentials(accountName, accountKey));
    
        cloudMediaContext = new CloudMediaContext(mediaServicesCredentials);
    
        return cloudMediaContext;
    }
    

Se il proprio account si trova in Cine settentrionale, usare il costruttore seguente:

public CloudMediaContext(Uri apiServer, string accountName, string accountKey, string scope, string acsBaseAddress)

Ad esempio:

_context = new CloudMediaContext(
    new Uri("https://wamsbjbclus001rest-hs.chinacloudapp.cn/API/"),
    _mediaServicesAccountName,
    _mediaServicesAccountKey,
    "urn:WindowsAzureMediaServices",
    "https://wamsprodglobal001acs.accesscontrol.chinacloudapi.cn");

È altamente consigliabile archiviare nella configurazione i valori di connessione, soprattutto dati sensibili come il nome account e la password, nonché crittografare i dati di configurazione sensibili. È possibile crittografare l'intero file di configurazione usando il sistema EFS (Encrypting File System) di Windows. Per abilitare EFS in un file, fare clic con il pulsante destro del mouse sul file, scegliere Proprietà e abilitare la crittografia nella scheda delle impostazioni Avanzate. In alternativa, è possibile creare una soluzione personalizzata per crittografare parti selezionate di un file di configurazione usando una configurazione protetta. Vedere Crittografia delle informazioni di configurazione tramite la configurazione protetta.

Il file App.config seguente contiene i valori di connessione necessari. I valori presenti nell'elemento <appSettings> sono i valori necessari che si ottengono dal processo di impostazione dell'account di Servizi multimediali.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
    </startup>
  <appSettings>
    <add key="MediaServicesAccountName" value="Add-Media-Services-Account-Name" />
    <add key="MediaServicesAccountKey" value="Add-Media-Services-Account-Key" />
  </appSettings>
</configuration>

Per recuperare i valori di connessione dalla configurazione, è possibile usare la classe ConfigurationManager e quindi assegnare i valori ai relativi campi del codice:

private static readonly string _accountName = ConfigurationManager.AppSettings["MediaServicesAccountName"];
private static readonly string _accountKey = ConfigurationManager.AppSettings["MediaServicesAccountKey"];

È possibile passare ora all'argomento successivo: Inserimento di asset con l'SDK di Servizi multimediali per .NET.

Vedere anche

Mostra:
© 2014 Microsoft