Como usar o Armazenamento de Blobs no XamarinHow to use Blob Storage from Xamarin

O Xamarin permite que os desenvolvedores usem uma base de código C# compartilhada para criar aplicativos iOS, Android e da Windows Store com suas interfaces de usuário nativo.Xamarin enables developers to use a shared C# codebase to create iOS, Android, and Windows Store apps with their native user interfaces. Este tutorial mostra como usar o armazenamento de Blobs do Azure com um aplicativo Xamarin.This tutorial shows you how to use Azure Blob storage with a Xamarin application. Se você quiser saber mais sobre o Armazenamento do Azure, antes de mergulharmos no código, confira Introdução ao Armazenamento do Microsoft Azure.If you'd like to learn more about Azure Storage, before diving into the code, see Introduction to Microsoft Azure Storage.

Criar uma conta de armazenamento do AzureCreate an Azure storage account

A maneira mais fácil de criar sua primeira conta de armazenamento do Azure é usando o portal do Azure.The easiest way to create your first Azure storage account is by using the Azure portal. Para saber mais, consulte Criar uma conta de armazenamento.To learn more, see Create a storage account.

Você também pode criar uma conta de armazenamento do Azure usando o Azure PowerShell, a CLI do Azure ou o Provedor de Recursos de Armazenamento do Azure para .NET.You can also create an Azure storage account by using Azure PowerShell, Azure CLI, or the Azure Storage Resource Provider for .NET.

Se você preferir não criar uma conta de armazenamento no Azure no momento, também poderá usar o emulador de armazenamento do Azure para executar e testar seu código em um ambiente local.If you prefer not to create a storage account in Azure at this time, you can also use the Azure storage emulator to run and test your code in a local environment. Para saber mais, confira Usar o Emulador de Armazenamento do Azure para desenvolvimento e teste.For more information, see Use the Azure Storage Emulator for Development and Testing.

Configurar seu aplicativo para acessar o Armazenamento de BlobConfigure your application to access Azure Storage

Há duas maneiras de autenticar o aplicativo para acessar os serviços de Armazenamento:There are two ways to authenticate your application to access Storage services:

  • Chave compartilhada: Usar a chave compartilhada somente para testesShared Key: Use Shared Key for testing purposes only
  • Assinatura de acesso compartilhado (SAS): Use a SAS para aplicativos de produçãoShared Access Signature (SAS): Use SAS for production applications

Chave compartilhadaShared Key

A autenticação de Chave Compartilhada significa que o aplicativo usará seu nome da conta e chave de conta para acessar os serviços de Armazenamento.Shared Key authentication means that your application will use your account name and account key to access Storage services. Para mostrar rapidamente como usar essa biblioteca, vamos usar a autenticação de Chave Compartilhada nesta introdução.For the purposes of quickly showing how to use this library, we will be using Shared Key authentication in this getting started.

Aviso

Use autenticação de chave compartilhada somente para fins de teste!Only use Shared Key authentication for testing purposes! Seu nome de conta e chave de conta, que dão acesso completo de leitura/gravação à conta de Armazenamento associada, serão distribuídos a todas as pessoas que baixarem o aplicativo.Your account name and account key, which give full read/write access to the associated Storage account, will be distributed to every person that downloads your app. Isso não é uma prática recomendada, pois você corre o risco de ter sua chave comprometida por clientes não confiáveis.This is not a good practice as you risk having your key compromised by untrusted clients.

Ao usar a autenticação de Chave Compartilhada, você criará uma cadeia de conexão.When using Shared Key authentication, you will create a connection string. A cadeia de conexão é composta dos seguintes itens:The connection string is comprised of:

  • O DefaultEndpointsProtocol -você pode escolher HTTP ou HTTPS.The DefaultEndpointsProtocol - you can choose HTTP or HTTPS. No entanto, é altamente recomendável usar HTTPS.However, using HTTPS is highly recommended.
  • O Nome da Conta - o nome de sua conta de armazenamentoThe Account Name - the name of your storage account
  • A Chave da Conta - no Portal do Azure, navegue até a conta de armazenamento e clique no ícone Chaves para encontrar essa informação.The Account Key - On the Azure Portal, navigate to your storage account and click the Keys icon to find this information.
  • (Opcional) EndpointSuffix - é usado para serviços de armazenamento em regiões com sufixos de ponto de extremidade diferentes, como o Azure China ou a Governança do Azure.(Optional) EndpointSuffix - This is used for storage services in regions with different endpoint suffixes, such as Azure China or Azure Governance.

Veja um exemplo de cadeia de conexão usando a autenticação de Chave Compartilhada:Here is an example of connection string using Shared Key authentication:

"DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here"

SAS (Assinaturas de Acesso Compartilhado)Shared Access Signatures (SAS)

Para um aplicativo móvel, o método recomendado para autenticar uma solicitação por um cliente em relação ao serviço de Armazenamento do Azure é usando uma SAS (Assinatura de Acesso Compartilhado).For a mobile application, the recommended method for authenticating a request by a client against the Azure Storage service is by using a Shared Access Signature (SAS). A SAS permite conceder a um cliente acesso a um recurso por um período de tempo especificado, com um conjunto de permissões especificado.SAS allows you to grant a client access to a resource for a specified period of time, with a specified set of permissions. Como proprietário da conta de armazenamento, você precisará gerar uma SAS a ser consumida por seus clientes móveis.As the storage account owner, you'll need to generate a SAS for your mobile clients to consume. Para gerar a SAS, provavelmente você desejará escrever um serviço separado que gere a SAS a ser distribuída a seus clientes.To generate the SAS, you'll probably want to write a separate service that generates the SAS to be distributed to your clients. Para fins de teste, você pode usar o Gerenciador de Armazenamento do Microsoft Azure ou o Portal do Azure para gerar um SAS.For testing purposes, you can use the Microsoft Azure Storage Explorer or the Azure Portal to generate a SAS. Ao criar a SAS, você pode especificar o intervalo de tempo em que a SAS é válida e as permissões que a SAS concede ao cliente.When you create the SAS, you can specify the time interval over which the SAS is valid, and the permissions that the SAS grants to the client.

O exemplo a seguir mostra como usar o Gerenciador de Armazenamento do Microsoft Azure para gerar uma SAS.The following example shows how to use the Microsoft Azure Storage Explorer to generate a SAS.

  1. Se você ainda não fez isso, Instale o Gerenciador de Armazenamento do Microsoft AzureIf you haven't already, Install the Microsoft Azure Storage Explorer

  2. Conecte-se à sua assinatura.Connect to your subscription.

  3. Clique em sua conta de armazenamento e clique na guia "Ações" na parte inferior esquerda.Click on your Storage account and click on the "Actions" tab at the bottom left. Clique em "Get Shared Access Signature" (Obter Assinatura de Acesso Compartilhado) para gerar uma "cadeia de conexão" para a SAS.Click "Get Shared Access Signature" to generate a "connection string" for your SAS.

  4. Aqui está um exemplo de uma cadeia de conexão de SAS que concede permissões leitura e gravação no serviço, contêiner e nível de objeto para o serviço Blob da conta de armazenamento.Here is an example of a SAS connection string that grants read and write permissions at the service, container and object level for the blob service of the Storage account.

    "SharedAccessSignature=sv=2015-04-05&ss=b&srt=sco&sp=rw&se=2016-07-21T18%3A00%3A00Z&sig=3ABdLOJZosCp0o491T%2BqZGKIhafF1nlM3MzESDDD3Gg%3D;BlobEndpoint=https://youraccount.blob.core.windows.net"

Como você pode ver, ao usar um SAS, você não expõe a chave de sua conta em seu aplicativo.As you can see, when using a SAS, you’re not exposing your account key in your application. Você pode aprender mais sobre SAS e práticas recomendadas para usar SAS fazendo check-out assinaturas de acesso compartilhado: Noções básicas sobre o modelo SAS.You can learn more about SAS and best practices for using SAS by checking out Shared Access Signatures: Understanding the SAS model.

Criar um novo aplicativo XamarinCreate a new Xamarin Application

Neste tutorial, criaremos um aplicativo para Android, iOS e Windows.For this tutorial, we'll be creating an app that targets Android, iOS, and Windows. Este aplicativo simplesmente criará um contêiner e carregará um blob nesse contêiner.This app will simply create a container and upload a blob into this container. Usaremos o Visual Studio no Windows, mas as mesmas lições podem ser aplicadas durante a criação de um aplicativo usando o Xamarin Studio no macOS.We'll be using Visual Studio on Windows, but the same learnings can be applied when creating an app using Xamarin Studio on macOS.

Execute estas etapas para criar o aplicativo:Follow these steps to create your application:

  1. Se você ainda não o fez, baixe e instale o Xamarin para Visual Studio.If you haven't already, download and install Xamarin for Visual Studio.
  2. Abra o Visual Studio e crie um aplicativo em branco (portátil nativo): O arquivo > novo projeto de > > entre plataformas > aplicativo em branco (portátil nativo) .Open Visual Studio, and create a Blank App (Native Portable): File > New > Project > Cross-Platform > Blank App(Native Portable).
  3. Clique com o botão direito no painel do Gerenciador de Soluções e selecione Gerenciar Pacotes NuGet para a Solução.Right-click your solution in the Solution Explorer pane and select Manage NuGet Packages for Solution. Procure por WindowsAzure.Storage e instale a versão estável mais recente para todos os projetos em sua solução.Search for WindowsAzure.Storage and install the latest stable version to all projects in your solution.
  4. Compile e execute seu projeto.Build and run your project.

Agora você deve ter um aplicativo que permite que você clique em um botão que incrementa um contador.You should now have an application that allows you to click a button which increments a counter.

Criar contêiner e carregar blobCreate container and upload blob

Em seguida, em seu projeto (Portable), adicione alguns códigos para MyClass.cs.Next, under your (Portable) project, you'll add some code to MyClass.cs. Esse código cria um contêiner e carrega um blob nesse contêiner.This code creates a container and uploads a blob into this container. MyClass.cs deve se parecer com o seguinte:MyClass.cs should look like the following:

using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Blob;
using System.Threading.Tasks;

namespace XamarinApp
{
    public class MyClass
    {
        public MyClass ()
        {
        }

        public static async Task performBlobOperation()
        {
            // Retrieve storage account from connection string.
            CloudStorageAccount storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here");

            // Create the blob client.
            CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

            // Retrieve reference to a previously created container.
            CloudBlobContainer container = blobClient.GetContainerReference("mycontainer");

            // Create the container if it doesn't already exist.
            await container.CreateIfNotExistsAsync();

            // Retrieve reference to a blob named "myblob".
            CloudBlockBlob blockBlob = container.GetBlockBlobReference("myblob");

            // Create the "myblob" blob with the text "Hello, world!"
            await blockBlob.UploadTextAsync("Hello, world!");
        }
    }
}

Substitua "your_account_name_here" e "your_account_key_here" pelo nome e chave de conta.Make sure to replace "your_account_name_here" and "your_account_key_here" with your actual account name and account key.

Todos os seus projetos para iOS, Android e Windows Phone têm referências ao seu projeto Portátil - ou seja, você pode escrever todo o código compartilhado em um só local e usá-lo em todos os seus projetos.Your iOS, Android, and Windows Phone projects all have references to your Portable project - meaning you can write all of your shared code in one place and use it across all of your projects. Agora você pode adicionar a seguinte linha de código a cada projeto para começar a aproveitar:MyClass.performBlobOperation()You can now add the following line of code to each project to start taking advantage: MyClass.performBlobOperation()

XamarinApp.Droid > MainActivity.csXamarinApp.Droid > MainActivity.cs

using Android.App;
using Android.Widget;
using Android.OS;

namespace XamarinApp.Droid
{
    [Activity (Label = "XamarinApp.Droid", MainLauncher = true, Icon = "@drawable/icon")]
    public class MainActivity : Activity
    {
        int count = 1;

        protected override async void OnCreate (Bundle bundle)
        {
            base.OnCreate (bundle);

            // Set our view from the "main" layout resource
            SetContentView (Resource.Layout.Main);

            // Get our button from the layout resource,
            // and attach an event to it
            Button button = FindViewById<Button> (Resource.Id.myButton);

            button.Click += delegate {
                button.Text = string.Format ("{0} clicks!", count++);
            };

            await MyClass.performBlobOperation();
            }
        }
    }
}

XamarinApp.iOS > ViewController.csXamarinApp.iOS > ViewController.cs

using System;
using UIKit;

namespace XamarinApp.iOS
{
    public partial class ViewController : UIViewController
    {
        int count = 1;

        public ViewController (IntPtr handle) : base (handle)
        {
        }

        public override async void ViewDidLoad ()
        {
            int count = 1;

            public ViewController (IntPtr handle) : base (handle)
            {
            }

            public override async void ViewDidLoad ()
            {
                base.ViewDidLoad ();
                // Perform any additional setup after loading the view, typically from a nib.
                Button.AccessibilityIdentifier = "myButton";
                Button.TouchUpInside += delegate {
                    var title = string.Format ("{0} clicks!", count++);
                    Button.SetTitle (title, UIControlState.Normal);
                };

                await MyClass.performBlobOperation();
            }

            public override void DidReceiveMemoryWarning ()
            {
                base.DidReceiveMemoryWarning ();
                // Release any cached data, images, etc. that aren't in use.
            }
        }
    }
}

XamarinApp.WinPhone > MainPage.xaml > MainPage.xaml.csXamarinApp.WinPhone > MainPage.xaml > MainPage.xaml.cs

using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Navigation;

// The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=391641

namespace XamarinApp.WinPhone
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        int count = 1;

        public MainPage()
        {
            this.InitializeComponent();

            this.NavigationCacheMode = NavigationCacheMode.Required;
        }

        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.
        /// This parameter is typically used to configure the page.</param>
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            int count = 1;

            public MainPage()
            {
                this.InitializeComponent();

                this.NavigationCacheMode = NavigationCacheMode.Required;
            }

            /// <summary>
            /// Invoked when this page is about to be displayed in a Frame.
            /// </summary>
            /// <param name="e">Event data that describes how this page was reached.
            /// This parameter is typically used to configure the page.</param>
            protected override async void OnNavigatedTo(NavigationEventArgs e)
            {
                // TODO: Prepare page for display here.

                // TODO: If your application contains multiple pages, ensure that you are
                // handling the hardware Back button by registering for the
                // Windows.Phone.UI.Input.HardwareButtons.BackPressed event.
                // If you are using the NavigationHelper provided by some templates,
                // this event is handled for you.
                Button.Click += delegate {
                    var title = string.Format("{0} clicks!", count++);
                    Button.Content = title;
                };

                await MyClass.performBlobOperation();
            }
        }
    }
}

Executar o aplicativoRun the application

Agora você pode executar esse aplicativo em um emulador do Android ou do Windows Phone.You can now run this application in an Android or Windows Phone emulator. Também é possível executar esse aplicativo em um emulador de iOS, mas isso exigirá um Mac.You can also run this application in an iOS emulator, but this will require a Mac. Para obter instruções específicas sobre como fazer isso, leia a documentação sobre como Conectar o Visual Studio a um MacFor specific instructions on how to do this, please read the documentation for connecting Visual Studio to a Mac

Após a execução do aplicativo, ele criará o contêiner mycontainer em sua conta de armazenamento.Once you run your app, it will create the container mycontainer in your Storage account. Ele deve conter o blob, myblob, que tem o texto Hello, world!.It should contain the blob, myblob, which has the text, Hello, world!. Você pode verificar isso usando o Gerenciador de Armazenamento do Microsoft Azure.You can verify this by using the Microsoft Azure Storage Explorer.

Próximas etapasNext steps

Neste tutorial, você aprendeu como criar um aplicativo de plataforma cruzada no Xamarin que usa o armazenamento do Azure, concentrando-se especificamente em um cenário no Armazenamento de Blobs.In this tutorial, you learned how to create a cross-platform application in Xamarin that uses Azure Storage, specifically focusing on one scenario in Blob Storage. No entanto, você pode fazer muito mais, não apenas com o Armazenamento de Blobs, mas também com o Armazenamento de Filas, de Tabelas e de Arquivo.However, you can do a lot more with not only Blob Storage, but also with Table, File, and Queue Storage. Para saber mais, veja os artigos a seguir:Please check out the following articles to learn more:

Dica

Como gerenciar os recursos de Armazenamento de Blobs do Azure com o Gerenciador de Armazenamento do Microsoft Azure.Manage Azure Blob storage resources with Azure Storage Explorer. O Gerenciador de Armazenamento do Microsoft Azure é um aplicativo independente e grátis da Microsoft que permite gerenciar recursos de armazenamento de Blob do Microsoft Azure.Azure Storage Explorer is a free, standalone app from Microsoft that enables you to manage Azure Blob storage resources. Com o Gerenciador de Armazenamento do Microsoft Azure, você pode criar, ler, atualizar e excluir visualmente contêineres de blobs e blobs, bem como gerenciar o acesso aos seus contêineres de blobs e blobs.Using Azure Storage Explorer, you can visually create, read, update, and delete blob containers and blobs, as well as manage access to your blobs containers and blobs.