Come usare l'archivio BLOB da iOS

Suggerimento

Gestire le risorse dell'archivio BLOB di Azure con Microsoft Azure Storage Explorer

Esplora archivi di Microsoft Azure è un'app autonoma gratuita di Microsoft che consente di gestire risorse di Archiviazione BLOB di Azure. Esplora archivi di Microsoft Azure consente di creare, leggere, aggiornare ed eliminare contenitori BLOB e BLOB, nonché di gestire l'accesso ai contenitori BLOB e ai BLOB.

Panoramica

Questa guida illustra i diversi scenari comuni di uso del servizio di archiviazione BLOB di Microsoft Azure. Gli esempi sono scritti in Objective-C e usano la libreria del client di archiviazione di Azure per iOS. Gli scenari illustrati includono caricamento, visualizzazione in elenchi, download e eliminazione di BLOB. Per ulteriori informazioni sui BLOB, vedere la sezione Passaggi successivi . È possibile scaricare l' app di esempio per visualizzare rapidamente l'uso di Archiviazione di Azure in un'applicazione iOS.

Informazioni sull'archiviazione BLOB

Archivio BLOB di Azure è un servizio per l'archiviazione di grandi quantità di dati oggetto non strutturati, ad esempio dati di testo o binari, a cui è possibile accedere da qualsiasi parte del mondo tramite HTTP o HTTPS. L'archiviazione BLOB può essere usata per esporre dati pubblicamente a livello mondiale o archiviare privatamente i dati delle applicazioni.

Quelli di seguito sono gli impieghi più comuni dell'archiviazione BLOB:

  • Invio di immagini o documenti direttamente in un browser
  • Archiviazione di file per l'accesso distribuito
  • Flussi audio e video
  • Archiviazione di dati per backup e ripristino, ripristino di emergenza e archiviazione
  • Archiviazione di dati a scopo di analisi da parte di un servizio locale o ospitato in Azure

Concetti del servizio BLOB

Il servizio BLOB è composto dai componenti seguenti:

Architettura BLOB

  • Account di archiviazione: l'accesso ad Archiviazione di Azure viene eseguito esclusivamente tramite un account di archiviazione. Questo può essere un account di archiviazione di uso generico o un account di archiviazione BLOB, specializzato per l'archiviazione di oggetti/BLOB. Per altre informazioni, vedere Informazioni sugli account di archiviazione di Azure.
  • Contenitore: un contenitore è un raggruppamento di un set di BLOB. Tutti i BLOB devono trovarsi in un contenitore. In un account può esistere un numero illimitato di contenitori. In un contenitore può essere archiviato un numero illimitato di BLOB. Il nome del contenitore deve essere in lettere minuscole.
  • BLOB: file di qualsiasi tipo e dimensione. Archiviazione di Azure offre tre tipi di BLOB: i BLOB in blocchi, i BLOB di pagine e i BLOB di accodamento.

    BLOB in blocchi sono ideali per l'archiviazione di file di testo o file binari, ad esempio i documenti e i file multimediali. BLOB di accodamento sono simili ai BLOB in blocchi in quanto sono costituiti da blocchi, ma sono ottimizzati per le operazioni di accodamento, in modo che siano utili per gli scenari di registrazione. Un singolo BLOB in blocchi può contenere fino a 50.000 blocchi da al massimo 100 MB ognuno, per una dimensione totale leggermente superiore a 4,75 TB (100 MB X 50.000). Un singolo BLOB di accodamento può contenere fino a 50.000 blocchi da al massimo 4 MB ognuno, per una dimensione totale leggermente superiore a 195 GB (4 MB X 50.000).

    BLOB di pagine possono avere un dimensione di al massimo 1 TB e sono più efficienti per operazioni di lettura/scrittura frequenti. Le Macchine virtuali di Azure utilizzano i BLOB di pagine come dischi del sistema operativo e dati.

    Per informazioni sulla denominazione di contenitori e BLOB, vedere l'articolo relativo alla denominazione e riferimento a contenitori, BLOB e metadati.

Creare un account di archiviazione di Azure

Il modo più semplice per creare il primo account di archiviazione di Azure consiste nell'usare il portale di Azure. Per altre informazioni, vedere Creare un account di archiviazione.

È anche possibile creare un account di archiviazione di Azure usando Azure PowerShell, l'interfaccia della riga di comando di Azure o la libreria client del provider di risorse di archiviazione per .NET.

Se si preferisce non creare un account di archiviazione in questa fase, è anche possibile usare l'emulatore di archiviazione di Azure per eseguire e testare il codice in un ambiente locale. Per altre informazioni, vedere Usare l'emulatore di archiviazione di Azure per sviluppo e test.

Importare la libreria iOS di Archiviazione di Azure nell'applicazione

È possibile importare la libreria iOS di archiviazione di Azure nell'applicazione tramite l'uso del CocoaPod di Archiviazione di Azure o importando il file Framework . CocoaPod è lo strumento consigliato, in quanto semplifica l'integrazione della libreria. Tuttavia, l'importazione dal file del framework è meno impegnativa per il progetto esistente.

Per usare questa libreria, sono necessari i componenti seguenti:

  • iOS 8+
  • Xcode 7+

CocoaPod

  1. Se non ancora installato, installare CocoaPod nel computer aprendo una finestra del terminale ed eseguendo il comando seguente

    sudo gem install cocoapods
    
  2. Successivamente, nella directory del progetto (la directory contenente il file con estensione xcodeproj), creare un nuovo file denominato Podfile (senza estensione). Aggiungere il codice seguente a Podfile e salvare.

    platform :ios, '8.0'
    
    target 'TargetName' do
      pod 'AZSClient'
    end
    
  3. Nella finestra del terminale passare alla directory del progetto ed eseguire il comando seguente

    pod install
    
  4. Se il file con estensione xcodeproj è aperto in Xcode, chiuderlo. Nella directory del progetto aprire il file di progetto appena creato che avrà l'estensione xcworkspace. Si tratta del file che verrà usato d'ora in poi.

Framework

L'altro modo per usare la libreria consiste nel creare il framework manualmente:

  1. Per prima cosa, scaricare o clonare il repository azure-storage-ios.
  2. Andare ad azure-storage-ios -> Lib -> Azure Storage Client Library e aprire AZSClient.xcodeproj in Xcode.
  3. In alto a sinistra in Xcode cambiare lo schema attivo da "Azure Storage Client Library" a "Framework".
  4. Compilare il progetto (⌘+B). Verrà creato un file AZSClient.framework sulla scrivania.

È quindi possibile importare il file framework nell'applicazione eseguendo le seguenti operazioni:

  1. Creare un nuovo progetto o aprire il progetto esistente in Xcode.
  2. Trascinare AZSClient.framework nella struttura del progetto Xcode.
  3. Selezionare Copy items if needed (Copia elementi se necessario) e fare clic su Add (Aggiungi).
  4. Fare clic sul progetto nel riquadro di spostamento a sinistra e fare clic sulla scheda General nella parte superiore dell'editor del progetto.
  5. Nella sezione Linked Frameworks and Libraries fare clic sul pulsante Add (+).
  6. Nell'elenco di librerie già fornito cercare libxml2.2.tbd e aggiungerla al progetto.

Importare la libreria

// Include the following import statement to use blob APIs.
#import <AZSClient/AZSClient.h>

Se si usa Swift, è necessario creare un'intestazione provvisoria e importare qui:

  1. Creare un file di intestazione Bridging-Header.h e aggiungere l'istruzione di importazione precedente.
  2. Passare alla scheda Build Settings (Impostazioni compilazione) e cercare Objective-C Bridging Header (Intestazione provvisoria Objective-C).
  3. Fare doppio clic nel campo di Objective-C Bridging Header (Intestazione provvisoria Objective-C) e aggiungere il percorso al file di intestazione: ProjectName/Bridging-Header.h
  4. Creare il progetto (⌘+B) per verificare che l'intestazione provvisoria sia stata prelevata da Xcode.
  5. È possibile iniziare a usare la libreria direttamente in qualsiasi file Swift, in quanto non è necessario importare istruzioni.

Configurare l'applicazione per l'accesso all'archiviazione di Azure

Per autenticare l'applicazione per accedere ai servizi di archiviazione, è possibile procedere in due modi:

  • Chiave condivisa: usare la Chiave condivisa solo a scopo di test
  • Firma di accesso condiviso: usare la firma di accesso condiviso per le applicazioni per la produzione

Chiave condivisa

L'autenticazione con la chiave condivisa implica che l'applicazione userà il nome account e la chiave dell'account per accedere ai servizi di archiviazione. Per mostrare rapidamente come usare questa libreria, in questa guida introduttiva verrà usata l'autenticazione con la chiave condivisa.

Avviso

Per scopi di test, usare solo l'autenticazione con chiave condivisa. Il nome account e la chiave dell'account, che concedono l'accesso completo in lettura/scrittura all'account di archiviazione associato, verranno distribuiti a ogni persona che scarica l'app. Questa procedura non è consigliabile perché si rischia che la chiave venga compromessa da client non attendibili.

Quando si usa l'autenticazione con la chiave condivisa, si creerà una stringa di connessione. La stringa di connessione è costituita da:

  • DefaultEndpointsProtocol : è possibile scegliere HTTP o HTTPS. Tuttavia, è vivamente consigliato l'uso di HTTPS.
  • Nome account : nome dell'account di archiviazione
  • Chiave account: se si usa il portale di Azure, passare all'account di archiviazione e fare clic sull'icona delle chiavi per trovare queste informazioni.
  • (Facoltativo) EndpointSuffix : usata per i servizi di archiviazione in aree con suffissi dell'endpoint diversi, ad esempio per Azure China o Azure Governance.

Ecco un esempio di stringa di connessione che usa l'autenticazione con la chiave condivisa:

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

Firme di accesso condiviso

Per un'applicazione mobile, il metodo consigliato per autenticare una richiesta da parte di un client in base al servizio di archiviazione di Azure è di usare una firma di accesso condiviso. La firma di accesso condiviso consente di concedere a un client l'accesso a una risorsa per un periodo di tempo specificato, con un set di autorizzazioni specificato. Il proprietario dell'account di archiviazione dovrà generare una firma di accesso condiviso che verrà usata dai client mobili. Per generare la firma di accesso condiviso da distribuire ai client, è possibile che si voglia scrivere un apposito servizio separato. A scopo di test è possibile usare Microsoft Azure Storage Explorer o il portale di Azure per generare una firma di accesso condiviso. Quando si crea la firma di accesso condiviso, è possibile specificare l'intervallo di tempo in cui la firma di accesso condiviso è valida e le autorizzazioni che la firma di accesso condiviso concede al client.

L'esempio seguente mostra come usare Esplora archivi di Microsoft Azure per generare una firma di accesso condiviso.

  1. Se non è già stato fatto, installare Esplora archivi di Microsoft Azure
  2. connessione alla sottoscrizione.
  3. Fare clic sull'account di archiviazione e quindi sulla scheda "Azioni" in basso a sinistra. Fare clic su "Get Shared Access Signature" (Ottieni firma di accesso condiviso) per generare una "stringa di connessione" per la firma di accesso condiviso.
  4. Di seguito è riportato un esempio di una stringa di connessione della firma di accesso condiviso che concede le autorizzazioni di lettura e scrittura a livello di servizio, contenitore e oggetto per il servizio BLOB dell'account di archiviazione.

    "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"

Come si può osservare, quando si usa una firma di accesso condiviso, non si espone la chiave dell'account nell'applicazione. Per altre informazioni sulla firma di accesso condiviso e sulle procedure consigliate per il relativo uso, vedere Firme di accesso condiviso, parte 1: conoscere il modello di firma di accesso condiviso.

Operazioni asincrone

Nota

Tutti i metodi che eseguono una richiesta al servizio sono operazioni asincrone. Negli esempi di codice si noterà che questi metodi hanno un gestore completamento. Il codice nel gestore completamento verrà eseguito dopo il completamento della richiesta. Il codice dopo il gestore completamento verrà eseguito mentre la richiesta è in corso.

Creare un contenitore

Ogni BLOB nell'archivio di Azure deve risiedere in un contenitore. L'esempio seguente mostra come creare un contenitore, denominato newcontainer, nell'account di archiviazione se non esiste già. Quando si sceglie un nome per il contenitore, tenere presenti le regole indicate in precedenza.

-(void)createContainer{
    NSError *accountCreationError;

    // Create a storage account object from a connection string.
    AZSCloudStorageAccount *account = [AZSCloudStorageAccount accountFromConnectionString:@"DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here" error:&accountCreationError];

    if(accountCreationError){
        NSLog(@"Error in creating account.");
    }

    // Create a blob service client object.
    AZSCloudBlobClient *blobClient = [account getBlobClient];

    // Create a local container object.
    AZSCloudBlobContainer *blobContainer = [blobClient containerReferenceFromName:@"newcontainer"];

    // Create container in your Storage account if the container doesn't already exist
    [blobContainer createContainerIfNotExistsWithCompletionHandler:^(NSError *error, BOOL exists) {
        if (error){
            NSLog(@"Error in creating container.");
        }
    }];
}

È possibile verificarne il funzionamento controllando Esplora archivi di Microsoft Azure e accertandosi che newcontainer sia nell'elenco di contenitori dell'account di archiviazione.

Impostare le autorizzazioni del contenitore

Per impostazione predefinita, le autorizzazioni di un contenitore vengono configurate per l'accesso Privato . I contenitori, tuttavia, offrono alcune opzioni diverse per l'accesso al contenitore:

  • Privato: dati BLOB e contenitore possono essere letti solo dal proprietario dell'account.
  • BLOB: i dati BLOB all'interno di questo contenitore possono essere letti tramite richiesta anonima, ma i dati del contenitore non sono disponibili. I client non possono enumerare i BLOB all'interno del contenitore tramite richiesta anonima.
  • Contenitore: dati BLOB e contenitore possono essere letti tramite richiesta anonima. I client possono enumerare i BLOB all'interno del contenitore tramite richiesta anonima, ma non sono in grado di enumerare i contenitori all'interno dell'account di archiviazione.

L'esempio seguente mostra come creare un contenitore con autorizzazioni di accesso Contenitore, che consentono l'accesso pubblico in sola lettura a tutti gli utenti in Internet:

-(void)createContainerWithPublicAccess{
    NSError *accountCreationError;

    // Create a storage account object from a connection string.
    AZSCloudStorageAccount *account = [AZSCloudStorageAccount accountFromConnectionString:@"DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here" error:&accountCreationError];

    if(accountCreationError){
        NSLog(@"Error in creating account.");
    }

    // Create a blob service client object.
    AZSCloudBlobClient *blobClient = [account getBlobClient];

    // Create a local container object.
    AZSCloudBlobContainer *blobContainer = [blobClient containerReferenceFromName:@"containerpublic"];

    // Create container in your Storage account if the container doesn't already exist
    [blobContainer createContainerIfNotExistsWithAccessType:AZSContainerPublicAccessTypeContainer requestOptions:nil operationContext:nil completionHandler:^(NSError *error, BOOL exists){
        if (error){
            NSLog(@"Error in creating container.");
        }
    }];
}

Caricare un BLOB in un contenitore

Come accennato nella sezione Concetti del servizio BLOB , l'archiviazione BLOB offre tre diversi tipi di BLOB: BLOB in blocchi, BLOB di accodamento e BLOB di pagine. La libreria iOS di Archiviazione di Azure supporta tutti e tre i tipi di BLOB. Nella maggior parte dei casi è consigliabile usare il tipo di BLOB in blocchi.

L'esempio seguente mostra come caricare un BLOB in blocchi da NSString. Se in questo contenitore esiste già un BLOB con lo stesso nome, i contenuti del BLOB verranno sovrascritti.

-(void)uploadBlobToContainer{
    NSError *accountCreationError;

    // Create a storage account object from a connection string.
    AZSCloudStorageAccount *account = [AZSCloudStorageAccount accountFromConnectionString:@"DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here" error:&accountCreationError];

    if(accountCreationError){
        NSLog(@"Error in creating account.");
    }

    // Create a blob service client object.
    AZSCloudBlobClient *blobClient = [account getBlobClient];

    // Create a local container object.
    AZSCloudBlobContainer *blobContainer = [blobClient containerReferenceFromName:@"containerpublic"];

    [blobContainer createContainerIfNotExistsWithAccessType:AZSContainerPublicAccessTypeContainer requestOptions:nil operationContext:nil completionHandler:^(NSError *error, BOOL exists)
        {
            if (error){
                NSLog(@"Error in creating container.");
            }
            else{
                // Create a local blob object
                AZSCloudBlockBlob *blockBlob = [blobContainer blockBlobReferenceFromName:@"sampleblob"];

                // Upload blob to Storage
                [blockBlob uploadFromText:@"This text will be uploaded to Blob Storage." completionHandler:^(NSError *error) {
                    if (error){
                        NSLog(@"Error in creating blob.");
                    }
                }];
            }
        }];
}

È possibile verificarne il funzionamento controllando Esplora archivi di Microsoft Azure e accertandosi che il contenitore containerpublic contenga il BLOB sampleblob. Poiché in questo esempio è stato usato un contenitore pubblico, per verificarne il funzionamento è anche possibile passare all'URI dei BLOB:

https://nameofyourstorageaccount.blob.core.windows.net/containerpublic/sampleblob

Oltre che per caricare un BLOB in blocchi da NSString, esistono metodi simili per NSData, NSInputStream o un file locale.

Elencare i BLOB in un contenitore

L'esempio seguente mostra come elencare tutti i BLOB in un contenitore. Quando si esegue questa operazione, tenere presenti i parametri seguenti:

  • continuationToken : il token di continuazione indica dove deve iniziare l'operazione di elenco. Se non viene specificato alcun token, i BLOB verranno elencati dall'inizio. È possibile elencare qualsiasi numero di BLOB, da zero a un massimo impostato. Anche se questo metodo restituisce zero risultati, se results.continuationToken non è nil, il servizio potrebbe includere altri BLOB che non sono stati elencati.
  • prefix : è possibile specificare il prefisso da usare per l'elenco di BLOB. Verranno elencati solo i BLOB che iniziano con questo prefisso.
  • useFlatBlobListing : come accennato nella sezione Assegnazione di nome e riferimento a contenitori e BLOB , anche se il servizio BLOB è uno schema di Archiviazione semplice, è possibile creare una gerarchia virtuale assegnando ai BLOB un nome con le informazioni sul percorso. Gli elenchi non semplici, tuttavia, non sono attualmente supportati. Questa funzionalità sarà disponibile a breve. Per ora, questo valore dovrebbe essere YES (Sì).

  • blobListingDetails : è possibile specificare quali elementi includere quando si elencano i BLOB

    • AZSBlobListingDetailsNone: elenca solo i BLOB di cui è stato eseguito il commit e non restituisce i metadati dei BLOB.
    • AZSBlobListingDetailsSnapshots: elenca i BLOB di cui è stato eseguito il commit e gli snapshot dei BLOB.
    • AZSBlobListingDetailsMetadata: recupera i metadati per ogni BLOB restituito nell'elenco.
    • AZSBlobListingDetailsUncommittedBlobs: elenca ii BLOB di cui è stato eseguito il commit e quelli per cui non è stato eseguito.
    • AZSBlobListingDetailsCopy: include le proprietà di copia nell'elenco.
    • AZSBlobListingDetailsAll: elenca tutti i BLOB di cui è stato eseguito il commit, quelli per cui non è stato eseguito e gli snapshot disponibili, nonché restituisce tutti i metadati e lo stato di copia per questi BLOB.
  • maxResults : numero massimo di risultati da restituire per questa operazione. Per non impostare un limite, usare -1.
  • completionHandler : blocco di codice da eseguire con i risultati dell'operazione di elenco.

In questo esempio viene usato un metodo helper per chiamare in modo ricorsivo il metodo list blobs ogni volta che viene restituito un token di continuazione.

-(void)listBlobsInContainer{
    NSError *accountCreationError;

    // Create a storage account object from a connection string.
    AZSCloudStorageAccount *account = [AZSCloudStorageAccount accountFromConnectionString:@"DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here" error:&accountCreationError];

    if(accountCreationError){
        NSLog(@"Error in creating account.");
    }

    // Create a blob service client object.
    AZSCloudBlobClient *blobClient = [account getBlobClient];

    // Create a local container object.
    AZSCloudBlobContainer *blobContainer = [blobClient containerReferenceFromName:@"containerpublic"];

    //List all blobs in container
    [self listBlobsInContainerHelper:blobContainer continuationToken:nil prefix:nil blobListingDetails:AZSBlobListingDetailsAll maxResults:-1 completionHandler:^(NSError *error) {
        if (error != nil){
            NSLog(@"Error in creating container.");
        }
    }];
}

//List blobs helper method
-(void)listBlobsInContainerHelper:(AZSCloudBlobContainer *)container continuationToken:(AZSContinuationToken *)continuationToken prefix:(NSString *)prefix blobListingDetails:(AZSBlobListingDetails)blobListingDetails maxResults:(NSUInteger)maxResults completionHandler:(void (^)(NSError *))completionHandler
{
    [container listBlobsSegmentedWithContinuationToken:continuationToken prefix:prefix useFlatBlobListing:YES blobListingDetails:blobListingDetails maxResults:maxResults completionHandler:^(NSError *error, AZSBlobResultSegment *results) {
        if (error)
        {
            completionHandler(error);
        }
        else
        {
            for (int i = 0; i < results.blobs.count; i++) {
                NSLog(@"%@",[(AZSCloudBlockBlob *)results.blobs[i] blobName]);
            }
            if (results.continuationToken)
            {
                [self listBlobsInContainerHelper:container continuationToken:results.continuationToken prefix:prefix blobListingDetails:blobListingDetails maxResults:maxResults completionHandler:completionHandler];
            }
            else
            {
                completionHandler(nil);
            }
        }
    }];
}

Scaricare un BLOB

L'esempio seguente mostra come scaricare un BLOB in un oggetto NSString.

-(void)downloadBlobToString{
    NSError *accountCreationError;

    // Create a storage account object from a connection string.
    AZSCloudStorageAccount *account = [AZSCloudStorageAccount accountFromConnectionString:@"DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here" error:&accountCreationError];

    if(accountCreationError){
        NSLog(@"Error in creating account.");
    }

    // Create a blob service client object.
    AZSCloudBlobClient *blobClient = [account getBlobClient];

    // Create a local container object.
    AZSCloudBlobContainer *blobContainer = [blobClient containerReferenceFromName:@"containerpublic"];

    // Create a local blob object
    AZSCloudBlockBlob *blockBlob = [blobContainer blockBlobReferenceFromName:@"sampleblob"];

    // Download blob
    [blockBlob downloadToTextWithCompletionHandler:^(NSError *error, NSString *text) {
        if (error) {
            NSLog(@"Error in downloading blob");
        }
        else{
            NSLog(@"%@",text);
        }
    }];
}

Eliminare un BLOB

L'esempio seguente mostra come eliminare un BLOB.

-(void)deleteBlob{
    NSError *accountCreationError;

    // Create a storage account object from a connection string.
    AZSCloudStorageAccount *account = [AZSCloudStorageAccount accountFromConnectionString:@"DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here" error:&accountCreationError];

    if(accountCreationError){
        NSLog(@"Error in creating account.");
    }

    // Create a blob service client object.
    AZSCloudBlobClient *blobClient = [account getBlobClient];

    // Create a local container object.
    AZSCloudBlobContainer *blobContainer = [blobClient containerReferenceFromName:@"containerpublic"];

    // Create a local blob object
    AZSCloudBlockBlob *blockBlob = [blobContainer blockBlobReferenceFromName:@"sampleblob1"];

    // Delete blob
    [blockBlob deleteWithCompletionHandler:^(NSError *error) {
        if (error) {
            NSLog(@"Error in deleting blob.");
        }
    }];
}

Eliminare un contenitore BLOB

L'esempio seguente mostra come eliminare un contenitore.

-(void)deleteContainer{
    NSError *accountCreationError;

    // Create a storage account object from a connection string.
    AZSCloudStorageAccount *account = [AZSCloudStorageAccount accountFromConnectionString:@"DefaultEndpointsProtocol=https;AccountName=your_account_name_here;AccountKey=your_account_key_here" error:&accountCreationError];

    if(accountCreationError){
        NSLog(@"Error in creating account.");
    }

    // Create a blob service client object.
    AZSCloudBlobClient *blobClient = [account getBlobClient];

    // Create a local container object.
    AZSCloudBlobContainer *blobContainer = [blobClient containerReferenceFromName:@"containerpublic"];

    // Delete container
    [blobContainer deleteContainerIfExistsWithCompletionHandler:^(NSError *error, BOOL success) {
        if(error){
            NSLog(@"Error in deleting container");
        }
    }];
}

Passaggi successivi

A questo punto, dopo avere appreso a usare l'archiviazione BLOB da iOS, seguire questi collegamenti per acquisire maggiori informazioni sulla libreria iOS e il servizio di archiviazione.

In caso di domande sulla libreria, è possibile pubblicare un post nel forum di Azure su MSDN o in Stack Overflow. Per inviare suggerimenti per Archiviazione di Azure, pubblicare un post nella pagina dei commenti e suggerimenti per Archiviazione di Azure.