Compartir a través de

Introducción a Azure Blob Storage mediante F#

Azure Blob Storage es un servicio que almacena datos no estructurados en la nube como objetos o blobs. El Almacenamiento de blobs puede almacenar cualquier tipo de datos binarios o texto, como un documento, un archivo multimedia o un instalador de aplicación. El almacenamiento de blobs también se conoce como almacenamiento de objetos.

En este artículo se muestra cómo realizar algunas tareas comunes con Blob Storage. Los ejemplos se escriben mediante F# con el Azure.Storage.Blobs paquete. Los tareas tratadas incluyen cómo cargar, enumerar, descargar y eliminar blobs.

Para obtener información general conceptual sobre Blob Storage, vea la guía de .NET para Blob Storage. Para mayor facilidad, en estos tutoriales se utilizan cadenas de conexión para autenticarse con Azure. En el caso de las aplicaciones de producción, debe usar microsoft Entra ID con identidades administradas o la biblioteca Azure.Identity para mejorar la seguridad.

Importante

En este artículo se usa el paquete moderno Azure.Storage.Blobs . Si se actualiza desde código anterior que usó los paquetes WindowsAzure.Storage o Microsoft.Azure.Storage.Blob en desuso, debe actualizar las referencias de paquete y los espacios de nombres. Para obtener instrucciones sobre la migración, consulte Migración a Azure.Storage.Blobs.

Nota:

Los desarrolladores de F# pueden considerar la biblioteca FSharp.Azure.Blob , que proporciona una API de F# más idiomática para trabajar con Azure Blob Storage. Esta biblioteca de la comunidad ofrece funciones y patrones de F# idiomáticos que hacen que las operaciones de blobs sean más naturales en F#.

Requisitos previos

Para usar esta guía, primero debe crear una cuenta de almacenamiento de Azure. También necesita la clave de acceso de almacenamiento de esta cuenta.

Crea un script de F# e inicia F# interactivo

Los ejemplos de este artículo se pueden usar en una aplicación de F# o en un script de F#. Para crear un script de F#, cree un archivo con la extensión .fsx, por ejemplo blobs.fsx, en el entorno de desarrollo de F#.

Ejecución de los scripts

F# interactivo, dotnet fsi, se puede iniciar de forma interactiva o desde la línea de comandos para ejecutar un script. La sintaxis de línea de comandos es

> dotnet fsi [options] [ script-file [arguments] ]

Incorporación de paquetes en un script

Utilice #rnuget:package name para instalar el paquete Azure.Storage.Blobs y open los espacios de nombres necesarios.

> #r "nuget: Azure.Storage.Blobs"
open Azure.Storage.Blobs
open Azure.Storage.Blobs.Models
open Azure.Storage.Blobs.Specialized

Añadir declaraciones de espacio de nombres

Añada las siguientes instrucciones open en la parte superior del archivo blobs.fsx:

open System
open System.IO
open Azure.Storage.Blobs // Namespace for Blob storage types
open Azure.Storage.Blobs.Models
open Azure.Storage.Blobs.Specialized
open System.Text

Obtén tu cadena de conexión

Necesita una cadena de conexión de Azure Storage para este tutorial. Para obtener más información sobre las cadenas de conexión, vea Configuración de las cadenas de conexión de Azure Storage.

En el tutorial, escriba la cadena de conexión en el script, así:

let storageConnString = "..." // fill this in from your storage account

Crea algunos datos ficticios locales

Antes de comenzar, cree algunos datos locales ficticios en el directorio del script. Más adelante cargará estos datos.

// Create a dummy file to upload
let localFile = "./myfile.txt"
File.WriteAllText(localFile, "some data")

Creación del cliente de Blob service

El tipo BlobContainerClient permite crear contenedores y recuperar blobs almacenados en Blob Storage. Esta es una forma de crear el cliente de contenedor:

let container = BlobContainerClient(storageConnString, "mycontainer")

Ahora ya puede escribir código para leer y escribir datos en el Almacenamiento de blobs.

Crear un contenedor

En este ejemplo se muestra cómo crear un contenedor si todavía no existe:

container.CreateIfNotExists()

De manera predeterminada, el nuevo contenedor es privado, lo que significa que debe especificar su clave de acceso de almacenamiento para descargar blobs de él. Si desea poner los archivos del contenedor a disposición de todo el mundo, puede convertir el contenedor en público utilizando el código siguiente:

let permissions = PublicAccessType.Blob
container.SetAccessPolicy(permissions)

Cualquier usuario de Internet puede ver los blobs de los contenedores públicos, pero solo es posible modificarlos o eliminarlos si se dispone de la clave de acceso apropiada o una firma de acceso compartido.

Cargar un blob en un contenedor

Azure Blob Storage admite blobs en bloques y en páginas. En la mayoría de los casos, se recomienda usar el tipo de blob en bloques.

Para cargar un archivo en un blob de bloques, consiga un cliente para el contenedor y úselo para obtener una referencia del blob de bloques. Una vez que disponga de la referencia de blob, puede cargar cualquier secuencia de datos en ella llamando al método Upload . Esta operación sobrescribe el contenido del blob y crea un nuevo blob en bloques si no existe ninguno.

// Retrieve reference to a blob named "myblob.txt".
let blockBlob = container.GetBlobClient("myblob.txt")

// Create or overwrite the "myblob.txt" blob with contents from the local file.
use fileStream = new FileStream(localFile, FileMode.Open, FileAccess.Read, FileShare.Read)
do blockBlob.Upload(fileStream)

Enumerar los blobs de un contenedor

Para enumerar los blobs de un contenedor, primero obtenga una referencia de contenedor. A continuación, puede utilizar el método GetBlobsByHierarchy del contenedor para recuperar los blobs y los directorios que contiene. Este método devuelve BlobItem objetos que proporcionan acceso a las propiedades y metadatos del blob.

for item in container.GetBlobsByHierarchy() do
    printfn $"Blob name: {item.Blob.Name}"

Por ejemplo, observe el siguiente conjunto de blobs en bloques incluidos en un contenedor denominado photos:

photo1.jpg
2015/architecture/description.txt
2015/architecture/photo3.jpg
2015/architecture/photo4.jpg
2016/arquitectura/photo5.jpg
2016/arquitectura/photo6.jpg
2016/arquitectura/description.txt
2016/photo7.jpg\

Al llamar a GetBlobsByHierarchy en un contenedor (como en el ejemplo anterior), se devuelve una lista jerárquica.

Directory: https://<accountname>.blob.core.windows.net/photos/2015/
Directory: https://<accountname>.blob.core.windows.net/photos/2016/
Block blob of length 505623: https://<accountname>.blob.core.windows.net/photos/photo1.jpg

Descargar blobs

Para descargar blobs, primero recupere una referencia de blob y, a continuación, llame al método DownloadTo . En el siguiente ejemplo, se usa el método DownloadTo para transferir el contenido del blob a un objeto de secuencia que, a continuación, puede guardar en un archivo local.

// Retrieve reference to a blob named "myblob.txt".
let blobToDownload = container.GetBlobClient("myblob.txt")

// Save blob contents to a file.
do
    use fileStream = File.OpenWrite("path/download.txt")
    blobToDownload.DownloadTo(fileStream)

También puede usar el método DownloadContent para descargar el contenido de un blob en forma de cadena de texto.

let text = blobToDownload.DownloadContent().Value.Content.ToString()

Eliminar blobs

Para eliminar un blob, primero obtenga una referencia al blob y luego llame al método Delete en él.

// Retrieve reference to a blob named "myblob.txt".
let blobToDelete = container.GetBlobClient("myblob.txt")

// Delete the blob.
blobToDelete.Delete()

Enumerar blobs en páginas de forma asincrónica

Si enumera un gran número de blobs o desea controlar el número de resultados que devuelve en una sola operación de listado, puede enumerar blobs en páginas de resultados. En este ejemplo se muestra cómo devolver resultados en páginas.

En este ejemplo se muestra una lista jerárquica mediante el GetBlobsByHierarchy método de BlobContainerClient.

let ListBlobsSegmentedInHierarchicalListing(container:BlobContainerClient) =
        // List blobs to the console window, with paging.
        printfn "List blobs in pages:"

        // Call GetBlobsByHierarchy to return an async collection 
        // of blobs in this container. AsPages() method enumerate the values 
        //a Page<T> at a time. This may make multiple service requests.

        for page in container.GetBlobsByHierarchy().AsPages() do
            for blobHierarchyItem in page.Values do 
                printf $"The BlobItem is : {blobHierarchyItem.Blob.Name} "

        printfn ""

Ahora se puede usar esta rutina de lista jerárquica como se indica a continuación. En primer lugar, cargue algunos datos ficticios (con el archivo local creado anteriormente en este tutorial).

for i in 1 .. 100 do
    let blob = container.GetBlobClient($"myblob{i}.txt")
    blob.Upload(localFile)

Ahora, ejecuta la rutina.

Escritura en un blob de anexión

Un blob de anexos está optimizado para operaciones de anexado, como el registro de eventos. Al igual que un blob de bloques, un blob de adición se compone de bloques, pero cuando se agrega un nuevo bloque a un blob de adición, siempre se añade al final del blob. No se puede actualizar o eliminar un bloque existente en un blob de anexión. Los identificadores de bloque para un blob de anexión no están expuestos como lo están para un blob de bloques.

Cada bloque en un blob de anexión puede tener un tamaño diferente, hasta un máximo de 4 MB, y un blob de anexión puede incluir un máximo de 50.000 bloques. El tamaño máximo de un blob en anexos es, por tanto, ligeramente superior a 195 GB (4 MB X 50.000 bloques).

En el ejemplo siguiente se crea un nuevo blob anexo y se le anexan algunos datos para simular una operación de registro sencilla.

let appendContainer = BlobContainerClient(storageConnString, "my-append-blobs")

// Create the container if it does not already exist.
appendContainer.CreateIfNotExists() |> ignore

// Get a reference to an append blob.
let appendBlob = appendContainer.GetAppendBlobClient("append-blob.log")

// Create the append blob. Note that if the blob already exists, the 
// CreateIfNotExists() method will overwrite it. You can check whether the 
// blob exists to avoid overwriting it by using appendBlob.Exists().
appendBlob.CreateIfNotExists()

let numBlocks = 10

// Generate an array of random bytes.
let rnd = Random()
let bytesArray = Array.zeroCreate<byte>(numBlocks)
rnd.NextBytes(bytesArray)

// Simulate a logging operation by writing text data and byte data to the 
// end of the append blob.
for i in 0 .. numBlocks - 1 do
    let msg = sprintf $"Timestamp: {DateTime.UtcNow} \tLog Entry: {bytesArray.[i]}\n"
    let array = Encoding.ASCII.GetBytes(msg);
    use stream = new MemoryStream(array)
    appendBlob.AppendBlock(stream)

// Read the append blob to the console window.
let downloadedText = appendBlob.DownloadContent().Value.Content.ToString()
printfn $"{downloadedText}"

Consulte Comprender los Blobs de Bloques, de Páginas y de Anexión para obtener más información acerca de las diferencias entre los tres tipos de blobs.

Acceso concurrente

Para permitir el acceso simultáneo a un blob desde varios clientes o varias instancias de proceso, puede usar etiquetas ETag o concesiones.

  • Etag : proporciona una manera de detectar que otro proceso ha modificado el blob o el contenedor

  • Arrendamiento: proporciona una manera de obtener acceso exclusivo, renovable, de escritura o eliminación a un blob durante un período de tiempo determinado.

Para obtener más información, vea Administración de la simultaneidad en Microsoft Azure Storage.

Nomenclatura de contenedores

Cada blob del almacenamiento de Azure debe residir en un contenedor. El contenedor forma parte del nombre del blob. Por ejemplo, mydata es el nombre del contenedor de estos URI de blob de ejemplo:

  • https://storagesample.blob.core.windows.net/mydata/blob1.txt
  • https://storagesample.blob.core.windows.net/mydata/photos/myphoto.jpg

Un nombre de contenedor debe ser un nombre DNS válido y cumplir las reglas de nomenclatura siguientes:

  1. Los nombres de contenedor deben comenzar por una letra o un número, y pueden contener solo letras, números y el carácter de guión (-).
  2. Todos los guiones (-) deben estar inmediatamente precedidos y seguidos por una letra o un número; no se permiten guiones consecutivos en los nombres de contenedores.
  3. Todas las letras del nombre de un contenedor deben aparecer en minúsculas.
  4. Los nombres de contenedor deben tener entre 3 y 63 caracteres de longitud.

El nombre de un contenedor siempre debe estar en minúsculas. Si se incluye una letra mayúscula en un nombre de contenedor o se infringe de algún otro modo las reglas de nomenclatura de contenedores, recibirá un error 400 (solicitud incorrecta).

Administración de la seguridad para blobs

De forma predeterminada, Azure Storage protege sus datos al limitar el acceso al propietario de la cuenta, quien está en posesión de las claves de acceso a ella. Cuando necesite compartir datos Blob en su cuenta de almacenamiento, es importante hacerlo sin poner en peligro la seguridad de las claves de acceso de la cuenta. Además, puede cifrar los datos Blob para asegurarse de que estén seguros durante la transmisión a través de la red y en el almacenamiento de Azure.

Controlar el acceso a los datos Blob

De forma predeterminada, los datos Blob de su cuenta de almacenamiento solo son accesibles para el propietario de la cuenta de almacenamiento. Para autenticar las solicitudes en el Almacenamiento de blobs, se necesita la clave de acceso de la cuenta por defecto. Pero puede que quiera que determinados datos de blob estén disponibles para otros usuarios.

Cifrado de datos Blob

Azure Storage admite el cifrado de datos de blob en el cliente y en el servidor.

Consulte también

  • Last updated on