Övning – Ladda upp resurser som ska användas av en Batch med .NET-lagringsbiblioteket

  • 10 minuter

Viktig

Du behöver en egen Azure-prenumeration för att köra den här övningen och du kan debiteras. Om du inte redan har en Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

Med Azure Storage-biblioteket kan du programmatiskt styra fillagring på ett Azure Storage-konto.

I den här övningen ska vi utöka appen för att ladda upp videor till bloblagring.

Lägg till anslutningsinformation för lagringskontot

  1. I Cloud Shell lägger du till NuGet-paketet för Azure Blob Storage:

    dotnet add package Microsoft.Azure.Storage.Blob

  2. Redigera filen Program.cs i redigeraren:

    code Program.cs

  3. Lägg till följande användningsinstruktioner överst i Program.cs för att inkludera de bibliotek som våra lagringsarbete behöver:

    using Microsoft.Azure.Storage.Blob;
using Microsoft.Azure.Storage;
using System.IO;

    Microsoft.Azure.Storage.Blob och Microsoft.Azure.Storage ge appen åtkomst till Azure Storage-kontot. System.IO ger appen åtkomst till filsystemet för filhantering.

  4. Lägg till variabler för Azure Storage-autentiseringsuppgifterna i klassen Program i Program.cs:

    // Storage account credentials
private const string envVarStorage = "STORAGE_NAME";
private const string envVarStorageKey = "STORAGE_KEY";
private static string storageAccountName;
private static string storageAccountKey;

Skapa en in- och utdatacontainer

  1. Ersätt Main() i Program.cs med följande uppdatering, som lägger till kod för att hantera lagringskontot:

    static async Task Main(string[] args)
{
    // Read the environment variables to allow the app to connect to the Azure Batch and Azure Storage accounts
    batchAccountUrl = Environment.GetEnvironmentVariable(envVarBatchURI);
    batchAccountName = Environment.GetEnvironmentVariable(envVarBatchName);
    batchAccountKey = Environment.GetEnvironmentVariable(envVarKey);
    storageAccountName = Environment.GetEnvironmentVariable(envVarStorage);
    storageAccountKey = Environment.GetEnvironmentVariable(envVarStorageKey);

    // Show the user the accounts they are attaching to
    Console.WriteLine("BATCH URL: {0}, Name: {1}, Key: {2}", batchAccountUrl, batchAccountName, batchAccountKey);
    Console.WriteLine("Storage Name: {0}, Key: {1}", storageAccountName, storageAccountKey);

    // Construct the Storage account connection string
    string storageConnectionString = String.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}",
                        storageAccountName, storageAccountKey);

    // Retrieve the storage account
    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString);

    // Create the blob client, for use in obtaining references to blob storage containers
    CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

    // Use the blob client to create the containers in blob storage
    const string inputContainerName = "input";
    const string outputContainerName = "output";

    await CreateContainerIfNotExistAsync(blobClient, inputContainerName);
    await CreateContainerIfNotExistAsync(blobClient, outputContainerName);

    // RESOURCE FILE SETUP
    // Add *.mp4 files into the \<solutiondir>\InputFiles folder.

    string inputPath = Path.Combine(Environment.CurrentDirectory, "InputFiles");
    List<string> inputFilePaths = new List<string>(
        Directory.GetFileSystemEntries(inputPath, "*.mp4", SearchOption.TopDirectoryOnly));

    // Upload data files.
    // Upload the data files using UploadResourceFilesToContainer(). This data will be
    // processed by each of the tasks that are executed on the compute nodes within the pool.
    List<ResourceFile> inputFiles = await UploadFilesToContainerAsync(blobClient, inputContainerName, inputFilePaths);

    // Obtain a shared access signature that provides write access to the output container to which
    // the tasks will upload their output.
    string outputContainerSasUrl = GetContainerSasUrl(blobClient, outputContainerName, SharedAccessBlobPermissions.Write);

    // The batch client requires a BatchSharedKeyCredentials object to open a connection
    var sharedKeyCredentials = new BatchSharedKeyCredentials(batchAccountUrl, batchAccountName, batchAccountKey);
    var batchClient = BatchClient.Open(sharedKeyCredentials);

    // Create the Batch pool, which contains the compute nodes that execute tasks.
    await CreateBatchPoolAsync(batchClient, PoolId);
}

    I föregående kod skapas ett CloudStorageAccount objekt för att göra det möjligt för appen att skapa en blobklient. Klienten används för att skapa lagringscontainrar, ladda upp filerna och ge åtkomst till jobbet för att skriva till utdatacontainern.

Skapa lagringscontainrar för in- och utdata för filer

  1. Lägg till följande metod, CreateContainerIfNotExistAsync(), för att skapa en container med det angivna namnet:

    private static async Task CreateContainerIfNotExistAsync(CloudBlobClient blobClient, string containerName)
{
    CloudBlobContainer container = blobClient.GetContainerReference(containerName);
    await container.CreateIfNotExistsAsync();
    Console.WriteLine("Creating container [{0}].", containerName);
}

    Föregående kod använder CloudBlobClient som skapats i metoden Main för att skapa containrar.

Bearbeta listan över alla filer som ska laddas upp

  1. Lägg till följande metod, UploadFilesToContainerAsync(), för att ladda upp en lista över indatafiler till containern:

    private static async Task<List<ResourceFile>> UploadFilesToContainerAsync(CloudBlobClient blobClient, string inputContainerName, List<string> filePaths)
{
    List<ResourceFile> resourceFiles = new List<ResourceFile>();

    foreach (string filePath in filePaths)
    {
        resourceFiles.Add(await UploadResourceFileToContainerAsync(blobClient, inputContainerName, filePath));
    }

    return resourceFiles;
}

    Föregående kod använder den skapade listan med filsökvägar för att anropa en metod för att ladda upp dem och lagra den skapade ResourceFile-referensen för användning av Batch-jobbet.

Ladda upp filerna

  1. Lägg till en metod för att ladda upp de lokala filerna till Azure Storage:

    private static async Task<ResourceFile> UploadResourceFileToContainerAsync(CloudBlobClient blobClient, string containerName, string filePath)
{
    Console.WriteLine("Uploading file {0} to container [{1}]...", filePath, containerName);

    string blobName = Path.GetFileName(filePath);
    var fileStream = System.IO.File.OpenRead(filePath);

    CloudBlobContainer container = blobClient.GetContainerReference(containerName);
    CloudBlockBlob blobData = container.GetBlockBlobReference(blobName);
    await blobData.UploadFromFileAsync(filePath);

    // Set the expiry time and permissions for the blob shared access signature. In this case, no start time is specified,
    // so the shared access signature becomes valid immediately
    SharedAccessBlobPolicy sasConstraints = new SharedAccessBlobPolicy
    {
        SharedAccessExpiryTime = DateTime.UtcNow.AddHours(2),
        Permissions = SharedAccessBlobPermissions.Read
    };

    // Construct the SAS URL for the blob
    string sasBlobToken = blobData.GetSharedAccessSignature(sasConstraints);
    string blobSasUri = String.Format("{0}{1}", blobData.Uri, sasBlobToken);

    return ResourceFile.FromUrl(blobSasUri, blobName);
}

    Föregående kod använder CloudBlobClient för att asynkront ladda upp filerna. Den skapar en resursfil som läggs till i en lista som aktiviteten som läggs till i nästa övning kommer att använda.

Aktivera åtkomst till utdatamappen

  1. Skapa en SAS-referens (Signatur för delad åtkomst) till utdatacontainern för uppgifter att skriva sina filer till:

    private static string GetContainerSasUrl(CloudBlobClient blobClient, string containerName, SharedAccessBlobPermissions permissions)
{
    // Set the expiry time and permissions for the container access signature. In this case, no start time is specified,
    // so the shared access signature becomes valid immediately. Expiration is in 2 hours.
    SharedAccessBlobPolicy sasConstraints = new SharedAccessBlobPolicy
    {
        SharedAccessExpiryTime = DateTime.UtcNow.AddHours(2),
        Permissions = permissions
    };

    // Generate the shared access signature on the container, setting the constraints directly on the signature
    CloudBlobContainer container = blobClient.GetContainerReference(containerName);
    string sasContainerToken = container.GetSharedAccessSignature(sasConstraints);

    // Return the URL string for the container, including the SAS token
    return String.Format("{0}{1}", container.Uri, sasContainerToken);
}

    Föregående kod skapar en SAS-URL med begränsad åtkomst (två timmar) för uppgiften så att den kan skriva de konverterade animerade GIF-filerna till Blob Storage.

  2. Högerklicka i kodredigeraren och välj Sparaoch högerklicka sedan och välj Avsluta.

Testa filuppladdningarna

  1. Skapa en InputFiles-mapp i din appkatalog i Cloud Shell:

    mkdir InputFiles

  2. Kör följande curl kommandon i Cloud Shell för att kopiera en uppsättning exempelvideor för husdjur från modulens GitHub-lagringsplats till den lokala mappen InputFiles.

    curl -L https://github.com/MicrosoftDocs/mslearn-apps-and-batch/raw/master/cutifypets/InputFiles/1.mp4 > ./InputFiles/1.mp4
curl -L https://github.com/MicrosoftDocs/mslearn-apps-and-batch/raw/master/cutifypets/InputFiles/2.mp4 > ./InputFiles/2.mp4
curl -L https://github.com/MicrosoftDocs/mslearn-apps-and-batch/raw/master/cutifypets/InputFiles/3.mp4 > ./InputFiles/3.mp4
curl -L https://github.com/MicrosoftDocs/mslearn-apps-and-batch/raw/master/cutifypets/InputFiles/4.mp4 > ./InputFiles/4.mp4
curl -L https://github.com/MicrosoftDocs/mslearn-apps-and-batch/raw/master/cutifypets/InputFiles/5.mp4 > ./InputFiles/5.mp4
curl -L https://github.com/MicrosoftDocs/mslearn-apps-and-batch/raw/master/cutifypets/InputFiles/6.mp4 > ./InputFiles/6.mp4

  3. Spara autentiseringsuppgifterna för Azure Storage i miljövariabler. Det andra kommandot använder miljövariabeln RESOURCE_GROUP som vi definierade i Konfigurera anslutningsinformation för programmet i den tidigare övningen Övning – Få åtkomst till ditt Batch-konto med hjälp av .NET-klientbiblioteket. Värdet är det resursgruppsnamn som du valde när du skapade ditt Batch-konto.

    export STORAGE_NAME=$(az storage account list --query "[?contains(name,'cuti')].name" --output tsv)
export STORAGE_KEY=$(az storage account keys list --account-name $STORAGE_NAME --query [0].value --output tsv --resource-group $RESOURCE_GROUP)

  4. Skapa och kör appen:

    dotnet run

  5. Programmet ska köra och skriva följande meddelanden till terminalen:

    BATCH URL: [your batch url], Name: [your batch account name], Key: [your batch key]
Storage Name: [your storage account name], Key: [your storage key]
Creating container [input].
Creating container [output].
Uploading file ~\cutifypets\InputFiles\3.mp4 to container [input]...
Uploading file ~\cutifypets\InputFiles\2.mp4 to container [input]...
Uploading file ~\cutifypets\InputFiles\4.mp4 to container [input]...
Uploading file ~\cutifypets\InputFiles\1.mp4 to container [input]...
Uploading file ~\cutifypets\InputFiles\5.mp4 to container [input]...
Uploading file ~\cutifypets\InputFiles\6.mp4 to container [input]...
Creating pool [WinFFmpegPool]...

Kontrollera de filer som laddats upp i Azure-portalen

  1. Gå tillbaka till Azure-portalen. I menyn till vänster väljer du Lagringskontonoch väljer sedan det lagringskonto som du skapade i den första övningen.

    Skärmbild som visar en användares lagringskonton.

  2. I menyn till vänster väljer du Behållare under Datalagringoch väljer sedan mappen inmatning.

    Skärmbild som visar de skapade containrarna i Blob Storage.

  3. Mappen innehåller de uppladdade videorna.

    Skärmbild som visar de uppladdade videofilerna.