Si querés una forma simple de guardar archivos “en la nube”, Azure Blob Storage es como tener una carpeta gigante y segura donde vas tirando cosas. Y desde Flask podés subir un archivo con muy poquitas líneas. Acá te cuento, en tono de amigo, qué hace la librería de Python por debajo y cómo levantar el Storage Account con Terraform sin marearte ni volverte loco o decir "estoi arto!"

Arranquemos imaginando un tren

Imaginá que tenés que mandar un paquete a otra ciudad. Necesitás vías para llegar, una estación donde sale todo, un andén específico para organizar los envíos, y un vagón donde viaja tu paquete. En esta historia:

  • Las vías las construye Terraform (deja todo listo y ordenado).
  • La estación es tu Storage Account de Azure.
  • El andén es el contenedor dentro del storage.
  • El vagón es el blob (tu archivo).
  • El maquinista es tu app Flask, que toma el archivo y lo sube.
  • El boleto para pasar controles es la connection string (y, si querés compartir, los SAS tokens).

Con esa imagen en mente,Vos ahora vas a ver que todo el viaje del archivo tiene lógica: Terraform arma la infraestructura (vías y estación) y Flask, con la librería de Azure, sube el archivo (lo pone en el vagón correcto y lo despacha).

¿Qué es Blob Storage y cómo piensa “las cosas”?

Imaginá tres niveles: la cuenta (tu “disco” en Azure), contenedores (carpetas) y blobs (archivos). Cuando subís un PDF o una imagen, eso es un blob dentro de un contenedor, que vive dentro de tu cuenta de almacenamiento. Listo. No hay más misterio.

La librería azure-storage-blob: qué hace y por qué es tan directa

En Python usamos la librería azure-storage-blob. Lo clave son tres “clientes”:

BlobServiceClient: es la puerta de entrada. Se crea con una connection string y desde ahí hablás con tu cuenta.

ContainerClient: apunta a un contenedor (una “carpeta”). Te deja crearlo, listar y subir/bajar blobs.

BlobClient: apunta a un archivo específico. Si querés subir algo concreto, este es tu “enchufe” directo.

¿El flujo típico para subir un archivo? Con Flask recibís el archivo del formulario, creás un nombre (mejor único), y llamás a upload_blob(...). Si ponés overwrite=True, no se queja si ese nombre ya existía. La librería se encarga de abrir conexión segura, fragmentar si hace falta y confirmar que llegó con éxito. Así de amable.

¿Qué pasa con la seguridad?

En clase, a veces usamos la connection string pegada en el código para no complicar. Pero en la vida real vas a querer variables de entorno (o un secret en tu CI/CD) para que esa llave no viaje por ahí. Más adelante podés generar SAS tokens (links con permiso y vencimiento) si querés compartir un archivo sin abrir todo el contenedor.

Terraform: armemos el Storage Account sin tocar el portal


# Azure Provider source and version being used
terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "=4.1.0"
    }
  }
}

provider "azurerm" {
  features {

  }
}


# create a resource group
resource "azurerm_resource_group" "rg" {
  name = "rg-storageaccount-file-uploader-rx"
  location = "East US"
}

# Create an storage account

resource "azurerm_storage_account" "storage_account" {
  name = "demox2025uploaderx"
  resource_group_name = azurerm_resource_group.rg.name
  location = azurerm_resource_group.rg.location
  account_tier = "Standard"
  account_replication_type = "LRS"
}

Ahora sí: levantemos la infraestructura con Terraform para que quede repetible y prolijo.

Primero, el proveedor de Azure en Terraform. Le decís “voy a usar Azure” y listo; Terraform se conecta con tus credenciales (las que tengas en tu CLI o variables de entorno). Después, creás:

Resource Group: el “folder” de Azure donde vive todo.

Storage Account: tu cuenta de almacenamiento. Acá elegís región, tipo de redundancia (por ejemplo LRS si querés barato y local), y modo Hot/Cool (Hot si lo vas a leer seguido).

Container: la “carpeta” adentro del storage donde vamos a subir los archivos.

Un par de tips de amigo para que no te frustres:

El nombre del Storage Account debe ser único a nivel global, solo minúsculas y números, y entre 3 y 24 caracteres. Algo tipo: stappclase123.

Si no necesitás algo raro, empezá con account_replication_type = "LRS" y access_tier = "Hot". Funciona bien para demos y pruebas.

Creá un contenedor simple, por ejemplo subidas-demo. Si querés acceso público (para descargar sin login) existe la propiedad public_access, pero no la actives en producción a la ligera.

Cuando Terraform termina, podés sacar “outputs” útiles: la connection string, el endpoint de blob, o el nombre del contenedor. Con eso alimentás tu app Flask sin andar copiando y pegando del portal. ¿Por qué está bueno? Porque si más adelante cambiás de región o clonás el entorno, tu app sigue funcionando con los nuevos datos sin tocar código.

Conectar Flask con lo que creaste en Terraform

Una vez creado el Storage con Terraform, vas a usar en Flask la connection string que Terraform te puede exponer como output. En la demo didáctica la podés pegar en el código; cuando pases a algo más serio, exportala como variable de entorno (por ejemplo AZURE_STORAGE_CONNECTION_STRING) y en Flask leés os.getenv(...). Con eso ya instanciás BlobServiceClient, apuntás al contenedor, y upload_blob hace la magia.

¿Cómo se siente todo junto en la práctica?

El usuario entra a tu página, elige un archivo y toca Subir. Flask recibe ese archivo en memoria (no hace falta guardarlo en disco), y la librería de Azure lo manda al contenedor. Si todo sale bien, le mostrás una URL. Si el contenedor es privado, ese link sirve para vos desde el portal o tu backend; si querés que cualquiera lo vea, generás un SAS con vencimiento (seguridad + comodidad).

Errores comunes que vas a evitar con esto

Nombre del storage inválido: recordá minúsculas y números.

Permisos/credenciales: si Terraform creó todo pero tu app no sube, revisá la connection string usada por Flask (¿es la de ese entorno?).

Tamaños grandes: para clase, bien. Para producción, pensá en límites, validaciones y manejo de tipos de archivo.

Con Terraform armás el Storage Account y su contenedor de forma limpia y repetible; con Flask + azure-storage-blob subís el archivo sin drama. Vos te enfocás en la experiencia del usuario, y la librería se encarga del transporte y la seguridad. Cuando quieras, te doy una versión con variables de entorno, SAS tokens y un par de pruebas automatizadas para que lo lleves a producción más tranquilo.

Repositorio del proyecto