Esercitazione: Introduzione all'SDK processi Web di Azure per l'elaborazione in background basata su eventi

  • Articolo

Introduzione all'SDK processi Web di Azure per Servizio app di Azure per consentire alle app Web di eseguire attività in background, attività pianificate e rispondere agli eventi.

Usare Visual Studio 2022 per creare un'app console .NET Core che usa WebJobs SDK per rispondere ai messaggi della coda di archiviazione di Azure, eseguire il progetto in locale e infine distribuirla in Azure.

In questa esercitazione verranno illustrate le procedure per:

  • Creare un'app console
  • Aggiungere una funzione
  • Test in locale
  • Distribuisci in Azure
  • Abilitare la registrazione di Application Insights
  • Aggiungere associazioni di input/output

Prerequisiti

Creare un'app console

In questa sezione si inizia creando un progetto in Visual Studio 2022. Si aggiungeranno quindi strumenti per lo sviluppo di Azure, la pubblicazione del codice e le funzioni in ascolto dei trigger e delle chiamate. Infine, si configura la registrazione della console che disabilita uno strumento di monitoraggio legacy e consente a un provider di console di filtrare predefinito.

Nota

Le procedure contenute in questo articolo vengono verificate per la creazione di un'app console .NET Core eseguita in .NET 6.0.

Creare un progetto

  1. In Visual Studio selezionare File>Nuovo>Progetto.

  2. In Crea un nuovo progetto selezionare Applicazione console (C#) e quindi selezionare Avanti.

  3. In Configura il nuovo progetto assegnare un nome al progetto WebJobsSDKSample e quindi selezionare Avanti.

  4. Scegliere il framework di destinazione e selezionare Crea. Questa esercitazione è stata verificata usando .NET 6.0.

Installare pacchetti NuGet di processi Web

Installare il pacchetto NuGet di processi Web più recente. Questo pacchetto include Microsoft.Azure.WebJobs (WebJobs SDK), che consente di pubblicare il codice della funzione in processi Web in Servizio app di Azure.

  1. Ottenere la versione più recente stabile 4.x del pacchetto NuGet Microsoft.Azure.WebJobs.Extensions.

  2. In Visual Studio passare a Strumenti>Gestione pacchetti NuGet.

  3. Selezionare Console di Gestione pacchetti. Verrà visualizzato un elenco di cmdlet NuGet, un collegamento alla documentazione e un PM> punto di ingresso.

  4. Nel comando seguente sostituire <4_X_VERSION> con il numero di versione corrente trovato nel passaggio 1.

    Install-Package Microsoft.Azure.WebJobs.Extensions -version <4_X_VERSION>

  5. Nella console di Gestione pacchetti eseguire il comando. L'elenco di estensioni viene visualizzato e viene installato automaticamente.

Creare l'host

L'host è il contenitore di runtime per le funzioni, che resta in ascolto dei trigger e chiama le funzioni. La procedura seguente crea un host che implementa IHost, ovvero l'host generico in ASP.NET Core.

  1. Selezionare la scheda Program.cs , rimuovere il contenuto esistente e aggiungere queste using istruzioni:

    using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;

  2. Anche in Program.cs aggiungere il codice seguente:

    namespace WebJobsSDKSample
{
    class Program
    {
        static async Task Main()
        {
            var builder = new HostBuilder();
            builder.ConfigureWebJobs(b =>
            {
                b.AddAzureStorageCoreServices();
            });
            var host = builder.Build();
            using (host)
            {
                await host.RunAsync();
            }
        }
    }
}

In ASP.NET Core le configurazioni dell'host vengono impostate chiamando metodi sull'istanza HostBuilder. Per altre informazioni, vedere Host generico .NET. Il metodo di estensione ConfigureWebJobs inizializza l'host WebJobs. In ConfigureWebJobsinizializzare estensioni di associazione specifiche, ad esempio l'estensione dell'associazione di archiviazione e impostare le proprietà di tali estensioni.

Abilitare la registrazione nella console

Configurare la registrazione della console che usa il framework di registrazione ASP.NET Core. Questo framework, Microsoft.Extensions.Logging, include un'API che funziona con un'ampia gamma di provider di registrazione predefiniti e di terze parti.

  1. Ottenere la versione stabile più recente del Microsoft.Extensions.Logging.Console pacchetto NuGet, che include Microsoft.Extensions.Logging.

  2. Nel comando seguente sostituire <6_X_VERSION> con il numero di versione corrente trovato nel passaggio 1. Ogni tipo di pacchetto NuGet ha un numero di versione univoco.

    Install-Package Microsoft.Extensions.Logging.Console -version <6_X_VERSION>

  3. Nella console di Gestione pacchetti compilare il numero di versione corrente ed eseguire il comando. L'elenco di estensioni viene visualizzato e viene installato automaticamente.

  4. Nella scheda Program.cs aggiungere questa using istruzione:

    using Microsoft.Extensions.Logging;

  5. Continuando in Program.cs, aggiungere il ConfigureLogging metodo a HostBuilder, prima del Build comando. Il metodo AddConsole aggiunge la registrazione nella console alla configurazione.

    builder.ConfigureLogging((context, b) =>
{
    b.AddConsole();
});

    Il metodo Main si presenta ora come segue:

    static async Task Main()
{
    var builder = new HostBuilder();
    builder.ConfigureWebJobs(b =>
            {
                b.AddAzureStorageCoreServices();
            });
    builder.ConfigureLogging((context, b) =>
            {
                b.AddConsole();
            });
    var host = builder.Build();
    using (host)
    {
        await host.RunAsync();
    }
}

    Questa aggiunta apporta queste modifiche:

    • Disabilita la registrazione nel dashboard. Il dashboard è uno strumento di monitoraggio legacy e la registrazione nel dashboard non è consigliata per scenari di produzione con velocità effettiva elevata.
    • Aggiunge il provider della console con i filtri predefiniti.

A questo punto è possibile aggiungere una funzione attivata dai messaggi in arrivo in una coda di Archiviazione di Azure.

Aggiungere una funzione

Una funzione è un'unità di codice eseguita su una pianificazione, viene attivata in base a eventi o viene eseguita su richiesta. Un trigger è in ascolto di un evento del servizio. Nel contesto di WebJobs SDK, attivato non fa riferimento alla modalità di distribuzione. I processi Web basati su eventi o pianificati creati con l'SDK devono essere sempre distribuiti come processi Web continui con l'abilitazione di "Always On".

In questa sezione viene creata una funzione attivata dai messaggi in una coda di archiviazione di Azure. Prima di tutto, è necessario aggiungere un'estensione di associazione per connettersi ad Archiviazione di Azure.

Installare l'estensione dei binding di Archiviazione

A partire dalla versione 3 di WebJobs SDK, per connettersi ai servizi di archiviazione di Azure è necessario installare un pacchetto di estensione di associazione di archiviazione separato.

Nota

A partire da 5.x, Microsoft.Azure.WebJobs.Extensions.Storage è stato suddiviso per servizio di archiviazione e ha eseguito la migrazione del metodo di estensione in base al AddAzureStorage() tipo di servizio.

  1. Ottenere la versione stabile più recente del pacchetto NuGet Microsoft.Azure.WebJobs.Extensions.Storage , versione 5.x.

  2. Nel comando seguente sostituire <5_X_VERSION> con il numero di versione corrente trovato nel passaggio 1. Ogni tipo di pacchetto NuGet ha un numero di versione univoco.

    Install-Package Microsoft.Azure.WebJobs.Extensions.Storage -Version <5_X_VERSION>

  3. Nella console di Gestione pacchetti eseguire il comando con il numero di versione corrente al PM> punto di ingresso.

  4. Continuando in Program.cs, nel ConfigureWebJobs metodo di estensione, aggiungere il AddAzureStorageQueues metodo nell'istanza HostBuilder (prima del Build comando) per inizializzare l'estensione Di archiviazione. A questo punto, il metodo è simile al ConfigureWebJobs seguente:

    builder.ConfigureWebJobs(b =>
{
    b.AddAzureStorageCoreServices();
    b.AddAzureStorageQueues();
});

  5. Aggiungere il codice seguente nel metodo dopo l'istanza Mainbuilder :

    builder.UseEnvironment(EnvironmentName.Development);

    L'esecuzione in modalità di sviluppo riduce il backoff esponenziale del polling della coda che può ritardare significativamente il tempo necessario per il runtime per trovare il messaggio e richiamare la funzione. È consigliabile rimuovere questa riga di codice o passare a Production quando si esegue lo sviluppo e il test.

    Il Main metodo dovrebbe ora essere simile all'esempio seguente:

    static async Task Main()
{
    var builder = new HostBuilder();
    builder.UseEnvironment(EnvironmentName.Development);
    builder.ConfigureLogging((context, b) =>
    {
        b.AddConsole();
    });
    builder.ConfigureWebJobs(b =>
    {
        b.AddAzureStorageCoreServices();
        b.AddAzureStorageQueues();
    });
    var host = builder.Build();
    using (host)
    {
        await host.RunAsync();
    }
}

Creare una funzione attivata da una coda

L'attributo QueueTrigger indica al runtime di chiamare questa funzione quando viene scritto un nuovo messaggio in una coda di archiviazione di Azure denominata queue. Il contenuto del messaggio nella coda viene passato al codice del metodo nel parametro message. Nel corpo del metodo vengono elaborati i dati del trigger. In questo esempio, il codice registra semplicemente il messaggio.

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto, selezionare Aggiungi>nuovo elemento e quindi selezionare Classe.

  2. Assegnare un nome al nuovo file di classe C# Functions.cs e selezionare Aggiungi.

  3. In Functions.cs sostituire il modello generato con il codice seguente:

    using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;

namespace WebJobsSDKSample
{
    public class Functions
    {
        public static void ProcessQueueMessage([QueueTrigger("queue")] string message, ILogger logger)
        {
            logger.LogInformation(message);
        }
    }
}

    È necessario contrassegnare la classe Functions come public static per consentire al runtime di accedere ed eseguire il metodo. Nell'esempio di codice precedente, quando un messaggio viene aggiunto a una coda denominata queue, la funzione viene eseguita e la message stringa viene scritta nei log. La coda monitorata è nell'account di archiviazione di Azure predefinito, che viene creato successivamente.

Il parametro message non deve necessariamente essere una stringa. È possibile eseguire l'associazione anche a un oggetto JSON, una matrice di byte o un oggetto CloudQueueMessage. Vedere l'utilizzo del trigger della coda. Ogni tipo di associazione (come code, BLOB o tabelle) presenta un diverso set di tipi di parametri a cui è possibile eseguire l'associazione.

Creare un account di archiviazione di Azure

L'emulatore di archiviazione di Azure eseguito in locale non dispone di tutte le funzionalità necessarie da WebJobs SDK. Si creerà un account di archiviazione in Azure e si configurerà il progetto per usarlo.

Per informazioni su come creare un account di archiviazione per utilizzo generico v2, vedere Creare un account di archiviazione di Azure.

Individuare e copiare la stringa di connessione

Per configurare l'archiviazione è necessaria una stringa di connessione. Mantenere questa stringa di connessione per i passaggi successivi.

  1. Nella portale di Azure passare all'account di archiviazione e selezionare Impostazioni.

  2. In Impostazioni selezionare Chiavi di accesso.

  3. Per la stringa di connessione in chiave1 selezionare l'icona Copia negli Appunti .

    Chiave

Configurare l'archiviazione per l'esecuzione in locale

WebJobs SDK cerca la stringa di connessione di archiviazione nelle impostazioni applicazione in Azure. In caso di esecuzione in locale, questo valore viene cercato nel file di configurazione locale o nelle variabili di ambiente.

  1. Fare clic con il pulsante destro del mouse sul progetto, selezionare Aggiungi>nuovo elemento, selezionare File di configurazione JSON JavaScript, assegnare un nome al nuovo file appsettings.json e selezionare Aggiungi.

  2. Nel nuovo file aggiungere un campo AzureWebJobsStorage, come illustrato nell'esempio seguente:

    {
    "AzureWebJobsStorage": "{storage connection string}"
}

  3. Sostituire {stringa di connessione di archiviazione} con la stringa di connessione copiata in precedenza.

  4. Selezionare il file appsettings.json in Esplora soluzioni e nella finestra Proprietà impostare l'azione Copia nella directory di output su Copia se più recente.

Poiché questo file contiene un segreto stringa di connessione, non è consigliabile archiviare il file in un repository di codice remoto. Dopo aver pubblicato il progetto in Azure, è possibile aggiungere la stessa impostazione dell'app stringa di connessione nell'app in Servizio app di Azure.

Test in locale

Compilare ed eseguire il progetto in locale e creare una coda di messaggi per attivare la funzione.

  1. Nella portale di Azure passare all'account di archiviazione e selezionare la scheda Code (1). Selezionare + Coda (2) e immettere la coda come nome coda (3). Selezionare quindi OK (4).

    Questa immagine mostra come creare una nuova coda di archiviazione di Azure.

  2. Fare clic sulla nuova coda e selezionare Aggiungi messaggio.

  3. Nella finestra di dialogo Aggiungi messaggio immettere Hello World! come testo del messaggio e quindi selezionare OK. È ora presente un messaggio nella coda.

    Crea coda

  4. Premere CTRL+F5 per eseguire il progetto.

    La console mostra che il runtime ha trovato la funzione. Poiché è stato usato l'attributo nella ProcessQueueMessage funzione, il QueueTrigger runtime processi Web ascolta i messaggi nella coda denominata queue. Quando trova un nuovo messaggio in questa coda, il runtime chiama la funzione, passando il valore della stringa di messaggio.

  5. Indietro alla finestra Coda e aggiornarla. Il messaggio non è più presente perché è stato elaborato dalla funzione in esecuzione in locale.

  6. Chiudere la finestra della console.

È ora possibile pubblicare il progetto WebJobs SDK in Azure.

Distribuisci in Azure

Durante la distribuzione si crea un'istanza del servizio app in cui si eseguiranno le funzioni. Quando si pubblica un'app console .NET in servizio app in Azure, viene eseguita automaticamente come processo Web. Per altre informazioni sulla pubblicazione, vedere Sviluppare e distribuire processi Web usando Visual Studio.

Creare le risorse di Azure

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e scegliere Pubblica.

  2. Nella finestra di dialogo PubblicaselezionareAzure per Destinazione e quindi avanti.

  3. Selezionare Processi Web di Azure per destinazione specifica e quindi selezionare Avanti.

  4. Sopra servizio app istanze selezionare il pulsante più (+) per creare un nuovo processo Web di Azure.

  5. Nella finestra di dialogo servizio app (Windows) usare le impostazioni di hosting nella tabella seguente.

    Impostazione Valore consigliato Descrizione
    Nome Nome globalmente univoco Nome che identifica in modo univoco la nuova app per le funzioni.
    Sottoscrizione Scegliere la sottoscrizione Sottoscrizione di Azure da usare.
    Gruppo di risorse myResourceGroup Nome del gruppo di risorse in cui creare l'app per le funzioni. Per creare un nuovo gruppo di risorse scegliere Nuovo.
    Piano di hosting Piano di servizio app Un piano di servizio app specifica la località, le dimensioni e le funzionalità della server farm Web che ospita l'app. Quando si ospitano più app, è possibile limitare i costi configurando le app Web in modo che condividano un singolo piano di servizio app. servizio app piani definiscono l'area, le dimensioni dell'istanza, il numero di scalabilità e lo SKU (Gratuito, Condiviso, Basic, Standard o Premium). Scegliere Nuovo per creare un nuovo piano di servizio app. I livelli gratuiti e di base non supportano l'opzione Always On per mantenere il sito in esecuzione continuamente.

    Finestra di dialogo Crea servizio app

  6. Selezionare Crea per creare un processo Web e le risorse correlate in Azure con queste impostazioni e distribuire il codice del progetto.

  7. Selezionare Fine per tornare alla pagina Pubblica .

Abilitare AlwaysOn

Per un processo Web continuo, è necessario abilitare l'impostazione Always On nel sito in modo che i processi Web vengano eseguiti correttamente. Se non si abilita AlwaysOn, il runtime passa inattivo dopo alcuni minuti di inattività.

  1. Nella pagina Pubblica selezionare i tre punti sopra Hosting per visualizzare le azioni del profilo di hosting e scegliere Apri in portale di Azure.

  2. In Impostazioni scegliere Impostazionigeneralidi configurazione>, impostare Always On su Attiva e quindi selezionare Salva e Continua per riavviare il sito.

Pubblicare il progetto

Con l'app Web creata in Azure, è possibile pubblicare il progetto Processi Web.

  1. Nella pagina Pubblica in Hosting selezionare il pulsante modifica e modificare il tipo di processo Web in Continuous e selezionare Salva. Ciò assicura che il processo Web venga eseguito quando i messaggi vengono aggiunti alla coda. I processi Web attivati vengono in genere usati solo per i webhook manuali.

    Modificare il tipo di processo Web dalla finestra Pubblica vs 2022.

  2. Selezionare il pulsante Pubblica nell'angolo superiore destro della pagina Pubblica . Al termine dell'operazione, il processo Web viene eseguito in Azure.

Creare un'impostazione dell'app di connessione di archiviazione

È necessario creare la stessa impostazione della stringa di connessione di archiviazione in Azure usata localmente nel file di configurazione appsettings.json. In questo modo è possibile archiviare in modo più sicuro la stringa di connessione e

  1. Nella pagina Pubblica profilo selezionare i tre punti sopra Hosting per visualizzare le azioni del profilo di hosting e scegliere Gestisci Servizio app di Azure impostazioni.

  2. In Impostazioni applicazione scegliere + Aggiungi impostazione.

  3. In Nuovo nome dell'impostazione dell'app digitare AzureWebJobsStorage e selezionare OK.

  4. In Remoto incollare la stringa di connessione dall'impostazione locale e selezionare OK.

La stringa di connessione è ora impostata nell'app in Azure.

Attivare la funzione in Azure

  1. Assicurarsi di non essere in esecuzione in locale. Chiudere la finestra della console se è ancora aperta. In caso contrario, l'istanza locale potrebbe essere la prima a elaborare eventuali messaggi di coda creati.

  2. Nella pagina Coda in Visual Studio aggiungere un messaggio alla coda come indicato in precedenza.

  3. Aggiornare la pagina Coda. Il nuovo messaggio non sarà presente perché è stato elaborato dalla funzione eseguita in Azure.

Abilitare la registrazione di Application Insights

Quando il processo Web viene eseguito in Azure, non è possibile monitorare l'esecuzione della funzione visualizzando l'output della console. Per poter monitorare il processo Web, è necessario creare un'istanza associata di Application Insights quando si pubblica il progetto.

Creare un'istanza di Application Insights

  1. Nella pagina Pubblica profilo selezionare i tre punti sopra Hosting per visualizzare le azioni del profilo di hosting e scegliere Apri nel portale di Azure.

  2. Nell'app Web in Impostazioni scegliere Application Insights e selezionare Attiva Application Insights.

  3. Verificare il nome della risorsa generato per l'istanza e la posizione e selezionare Applica.

  4. In Impostazioni scegliere Configurazione e verificare che sia stato creato un nuovo APPINSIGHTS_INSTRUMENTATIONKEY oggetto. Questa chiave viene usata per connettere l'istanza di processo Web a Application Insights.

Per sfruttare la registrazione di Application Insights , è necessario aggiornare anche il codice di registrazione.

Installare l'estensione Application Insights

  1. Ottenere la versione stabile più recente del pacchetto NuGet Microsoft.Azure.WebJobs.Logging.ApplicationInsights , versione 3.x.

  2. Nel comando seguente sostituire <3_X_VERSION> con il numero di versione corrente trovato nel passaggio 1. Ogni tipo di pacchetto NuGet ha un numero di versione univoco.

    Install-Package Microsoft.Azure.WebJobs.Logging.ApplicationInsights -Version <3_X_VERSION>

  3. Nella console di Gestione pacchetti eseguire il comando con il numero di versione corrente al PM> punto di ingresso.

Inizializzare il provider di registrazione di Application Insights

Aprire Program.cs e aggiungere l'inizializzatore seguente in ConfigureLogging dopo la chiamata a AddConsole:

// If the key exists in settings, use it to enable Application Insights.
string instrumentationKey = context.Configuration["APPINSIGHTS_INSTRUMENTATIONKEY"];
if (!string.IsNullOrEmpty(instrumentationKey))
{
    b.AddApplicationInsightsWebJobs(o => o.InstrumentationKey = instrumentationKey);
}

Il codice del Main metodo dovrebbe ora essere simile all'esempio seguente:

static async Task Main()
{
    var builder = new HostBuilder();
    builder.UseEnvironment(EnvironmentName.Development);
    builder.ConfigureWebJobs(b =>
            {
                b.AddAzureStorageCoreServices();
                b.AddAzureStorage();
            });
    builder.ConfigureLogging((context, b) =>
            {
                b.AddConsole();

                // If the key exists in settings, use it to enable Application Insights.
                string instrumentationKey = context.Configuration["APPINSIGHTS_INSTRUMENTATIONKEY"];
                if (!string.IsNullOrEmpty(instrumentationKey))
                {
                    b.AddApplicationInsightsWebJobs(o => o.InstrumentationKey = instrumentationKey);
                }
            });
    var host = builder.Build();
    using (host)
    {
        await host.RunAsync();
    }
}

In questo modo il provider di registrazione di Application Insights viene inizializzato con il filtro predefinito. Durante l'esecuzione in locale, tutti i log di informazioni e di livello superiore vengono scritti sia nella console che in Application Insights.

Ripubblicare il progetto e attivare nuovamente la funzione

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e scegliere Pubblica.

  2. Come in precedenza, usare il portale di Azure per creare un messaggio di coda simile a quello precedente, ad eccezione di Hello App Insights! come testo del messaggio.

  3. Nella pagina Pubblica profilo selezionare i tre punti sopra Hosting per visualizzare le azioni del profilo di hosting e scegliere Apri nel portale di Azure.

  4. Nell'app Web in Impostazioni scegliere Application Insights e selezionare Visualizza dati di Application Insights.

  5. Selezionare Cerca e quindi selezionare Visualizza tutti i dati nelle ultime 24 ore.

    Selezionare Ricerca

  6. Se non viene visualizzato il messaggio Hello App Insights! selezionare Aggiorna periodicamente per diversi minuti. I log non vengono visualizzati immediatamente, perché richiede un po' di tempo per il client di Application Insights per scaricare i log elaborati.

    Log in Application Insights

Aggiungere associazioni di input/output

Le associazioni semplificano il codice che legge e scrive i dati. Le associazioni di input semplificano il codice per la lettura di dati. Le associazioni di output semplificano il codice per la scrittura di dati.

Aggiungere associazioni

Le associazioni di input semplificano il codice per la lettura di dati. Per questo esempio, il messaggio della coda è il nome di un BLOB, che verrà usato per trovare e leggere un BLOB in Archiviazione di Azure. Si useranno quindi associazioni di output per scrivere una copia del file nello stesso contenitore.

  1. In Functions.cs aggiungere un usingoggetto :

    using System.IO;

  2. Sostituire il metodo ProcessQueueMessage con il codice seguente:

    public static void ProcessQueueMessage(
    [QueueTrigger("queue")] string message,
    [Blob("container/{queueTrigger}", FileAccess.Read)] Stream myBlob,
    [Blob("container/copy-{queueTrigger}", FileAccess.Write)] Stream outputBlob,
    ILogger logger)
{
    logger.LogInformation($"Blob name:{message} \n Size: {myBlob.Length} bytes");
    myBlob.CopyTo(outputBlob);
}

    In questo codice, queueTrigger è un'espressione di associazione che viene risolta in un diverso valore in fase di esecuzione. In fase di esecuzione corrisponde al contenuto del messaggio nella coda.

    Questo codice usa associazioni di output per creare una copia del file identificato dal messaggio della coda. La copia del file è preceduta dal prefisso copia-.

  3. In Program.cs, nel ConfigureWebJobs metodo di estensione aggiungere il AddAzureStorageBlobs metodo nell'istanza HostBuilder (prima del Build comando) per inizializzare l'estensione Di archiviazione. A questo punto, il metodo è simile al ConfigureWebJobs seguente:

    builder.ConfigureWebJobs(b =>
{
    b.AddAzureStorageCoreServices();
    b.AddAzureStorageQueues();
    b.AddAzureStorageBlobs();
});

  4. Creare un contenitore BLOB nell'account di archiviazione.

    a. Nella portale di Azure passare alla scheda Contenitori sotto Archiviazione dati e selezionare + Contenitore

    b. Nella finestra di dialogo Nuovo contenitore immettere il contenitore come nome del contenitore e quindi selezionare Crea.

  5. Caricare il file Program.cs nel contenitore BLOB. Questo file viene qui usato come esempio. È possibile caricare qualsiasi file di testo e creare un messaggio nella coda con il nome del file.

    a. Selezionare il nuovo contenitore creato

    b. Selezionare il pulsante Carica.

    Pulsante per il caricamento di BLOB

    c. Trovare e selezionare Program.cs e quindi selezionare OK.

Ripubblicare il progetto

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e scegliere Pubblica.

  2. Nella finestra di dialogo Pubblica assicurarsi che il profilo corrente sia selezionato e quindi selezionare Pubblica. I risultati della pubblicazione sono descritti in dettaglio nella finestra Output.

  3. Creare un messaggio nella coda creata in precedenza, con Program.cs come testo del messaggio.

    Messaggio nella coda per Program.cs

  4. Una copia del file , copy-Program.cs, verrà visualizzata nel contenitore BLOB.

Passaggi successivi

Questa esercitazione illustra come creare, eseguire e distribuire un progetto WebJobs SDK 3.x.

Altre informazioni su WebJobs SDK