DEV Community

Cover image for Dónde Persisten los Datos de Mi Aplicación Laravel en un Entorno Efímero (Donde Ni el Disco Te Salva)
Hermann D. Schimpf
Hermann D. Schimpf

Posted on Edited on Originally published at hds-solutions.net

Dónde Persisten los Datos de Mi Aplicación Laravel en un Entorno Efímero (Donde Ni el Disco Te Salva)

English version here.


Lambda Entorno Efímero


Spoiler: El disco de Lambda existe. Es efímero, de solo lectura y se autodestruye cuando AWS recicla el entorno — y no avisa cuándo.


En el capítulo anterior convertimos a Laravel en un nómada digital: desplegamos en Lambda, servimos los assets con CloudFront y ganamos la batalla del cold-start con Octane. Pero quedó una promesa pendiente: ¿dónde van a parar los datos cuando el disco es, literalmente, una ilusión temporal?

Hablemos claro: el disco en Lambda existe. Hay un directorio /tmp escribible donde pueden tirar archivos temporales 1. Pero tratarlo como almacenamiento real es como guardar tus ahorros en un taxi compartido: técnicamente están ahí, pero buena suerte encontrándolos mañana. El resto del filesystem es de solo lectura, y cada instancia de Lambda puede desaparecer en cualquier momento llevándose /tmp con ella.

En este capítulo atacamos la persistencia en tres actos: primero los archivos (S3, la parte corta), después nuestra entrada al mundo NoSQL con caché y sesiones (DynamoDB, modo fácil), y finalmente el plato fuerte: DynamoDB como base de datos principal.


1. El Mapa del Tesoro Serverless

Antes de meternos en el código, ubiquemos dónde estamos parados. Esta es la arquitectura simplificada de mi aplicación:

AWS Serverless architecture

En los capítulos previos ya hablamos sobre cómo utilizamos Lambda para ejecutar nuestra App Laravel, y cómo CloudFront reparte el tráfico entre S3 (assets) y Lambda (la app). Hoy toca:

  • Enviar las subidas a S3.
  • Almacenar los datos de sesión y caché en DynamoDB.
  • y utilizar DynamoDB como nuestra base de datos principal.

Los demás servicios quedan para los próximos capítulos. Paciencia, mis jóvenes padawans.


2. Uploads a S3: La Parte Corta

Este punto es tan simple que casi da vergüenza dedicarle una sección. Casi.

a) El mismo facade de siempre, otro destino

Laravel ya abstrae el almacenamiento con el facade Storage. En un servidor tradicional apunta al disco local; en serverless, simplemente definimos el bucket 2 y cambiamos el driver a s3 3 4:

composer require league/flysystem-aws-s3-v3
Enter fullscreen mode Exit fullscreen mode
provider:
  environment:
    FILESYSTEM_DISK: s3
    AWS_BUCKET: ${construct:storage.bucketName}

constructs:
  storage:
    type: storage
    # Flysystem envía headers ACL en cada operación y los buckets nuevos los rechazan por defecto [^12]
    allowAcl: true
    # CORS es requerido para subir ficheros directamente desde el navegador utilizando URLs pre-firmadas
    cors: ${construct:website.url}
Enter fullscreen mode Exit fullscreen mode

Y listo. Toda llamada a Storage::put(), Storage::get() ahora habla con S3 sin tocar una línea de lógica de negocio. Cero refactor, pura abstracción, punto para Laravel.

b) URLs pre-firmadas: para que los uploads ni siquiera pasen por Lambda

Pero acá viene el truco fino. Si el usuario sube un archivo a través de la aplicación, están pagando tiempo de Lambda por bytes que solo están de paso. ¿Recuerdan la factura de $530 por tiempo inactivo del artículo anterior? Exacto.

La alternativa elegante: URLs pre-firmadas 5. Laravel genera una URL temporal de S3, el frontend la usa para subir el archivo directamente a S3, y Lambda ni se entera:

use Illuminate\Support\Facades\Storage;

// Laravel genera la URL, el navegador sube directo a S3
['url' => $url, 'headers' => $headers] = Storage::temporaryUploadUrl(
    "uploads/{$filename}", now()->addMinutes(5)
);
Enter fullscreen mode Exit fullscreen mode

El archivo viaja directo desde el navegador a S3 sin escalas. Generar la URL es una firma local, costo cero. Lambda sigue durmiendo, y sus billeteras también.

Lambda (y API Gateway) limitan el payload a un máximo de 6 MB y 10 MB respectivamente 6. Pasado ese tamaño, las URLs pre-firmadas dejan de ser una optimización y se vuelven obligatorias 7.

Pero, si Lambda sigue durmiendo... ¿Cómo se entera de que se subió un archivo?

Ahí empieza lo divertido: S3 puede disparar eventos automáticamente 8 cuando se sube un archivo. Ese evento puede invocar una Lambda, transmitir un mensaje por SNS, emitir un evento a SQS o EventBridge. Pero esa caja de Pandora la abriremos en otro capítulo.


3. DynamoDB, Modo Fácil: Caché y Sesiones

Antes de usar DynamoDB como base de datos (el boss final de este artículo), empecemos por donde duele menos: el caché y las sesiones.

a) Caché: la tabla que se limpia sola

La configuración es insultantemente simple 9. Solo debemos cambiar el store de caché a dynamodb, y especificar el nombre de la tabla DynamoDB:

provider:
  environment:
    CACHE_STORE: dynamodb
    DYNAMODB_CACHE_TABLE: !Ref CacheTable
Enter fullscreen mode Exit fullscreen mode

Y agregar la definición de tabla en serverless.yml (dentro de resources, como CloudFormation) 10:

CacheTable:
  Type: AWS::DynamoDB::Table
  Properties:
    TableName: my-app-cache
    BillingMode: PAY_PER_REQUEST
    AttributeDefinitions:
      - AttributeName: key
        AttributeType: S
      TimeToLiveSpecification:
        AttributeName: expires_at
        Enabled: true
      KeySchema:
        - AttributeName: key
          KeyType: HASH
Enter fullscreen mode Exit fullscreen mode

El detalle hermoso: TimeToLiveSpecification. DynamoDB borra automáticamente los items expirados según el atributo expires_at 11. Sin cron jobs de limpieza, sin comandos cache:*, sin nada. El Roomba de DynamoDB hace el aseo mientras ustedes duermen.

Los atributos key y expires_at son los nombres por defecto que utiliza Laravel 9.

b) Un nuevo hogar para las sesiones

En el artículo anterior dejamos las sesiones en cookies como solución rápida. Funciona sí, pero tiene sus límites: las cookies viajan en cada request y tienen tope de ~4KB. Para algo más robusto, Laravel trae soporte nativo para DynamoDB 12:

provider:
  environment:
    SESSION_DRIVER: dynamodb
Enter fullscreen mode Exit fullscreen mode

Internamente, Laravel reutiliza la misma tabla de caché 12 (con el mismo TTL automático 11). Las sesiones expiran, DynamoDB las barre, y ustedes siguen programando features en vez de mantener infraestructura.

El trade-off honesto: las cookies eran gratis; ahora cada request autenticado es una lectura y una escritura en DynamoDB. Con PAY_PER_REQUEST y tráfico modesto hablamos de centavos al mes, pero conviene saberlo antes de que aparezca en la factura.

Con caché y sesiones ya migrados, solo queda un componente stateful en pie: la base de datos.

Preparen café, que aquí se pone interesante.


4. DynamoDB como Base de Datos: El Boss Final

Acá es donde la mayoría de los devs Laravel se ponen nerviosos. Durante toda nuestra carrera fuimos criados a base de CREATE TABLE, migraciones y JOINs. DynamoDB mira todo eso y dice: "qué lindo, pero acá no hacemos nada de eso".

We don't do that here - Black Panther Meme

a) Básicos de DynamoDB para devs Laravel

Traduzcamos los conceptos a nuestro idioma:

  • Tabla: igual que siempre, pero sin migraciones ni columnas: cada item puede tener los atributos que quiera. La única excepción son los atributos que usen como clave o índice 13: esos sí hay que declararlos.
  • Item: el equivalente a una fila. Básicamente un JSON con identidad propia.
  • PK (Partition Key): define en qué partición física vive el item. Es el WHERE obligatorio de toda consulta. La única que se salva es Scan, pero en la sección 4.d van a ver por qué no querrán usarla.
  • SK (Sort Key): ordena los items dentro de una misma partición. PK + SK forman la clave primaria compuesta.
  • GSI (Global Secondary Index) 14: una forma alternativa de organizar los items para consultarlos por otros atributos. Lo más parecido a un índice que van a encontrar.

La regla de oro que me costó interiorizar: en DynamoDB no modelan datos, modelan los patrones de acceso. Primero piensan qué queries van a hacer, después diseñan las claves. A diferencia de SQL, donde modelan normalizado y después se pelean con los índices.

b) Eloquent sobre DynamoDB: kitar/laravel-dynamodb

Para simplificar la implementación de Eloquent con DynamoDB utilicé el paquete kitar/laravel-dynamodb, que provee un driver de conexión y un query builder que traduce las llamadas de Eloquent a operaciones de DynamoDB.

composer require kitar/laravel-dynamodb
Enter fullscreen mode Exit fullscreen mode

La conexión en config/database.php se ve así:

'dynamodb' => [
    'driver'   => 'dynamodb',
    'key'      => env('AWS_ACCESS_KEY_ID'),
    'secret'   => env('AWS_SECRET_ACCESS_KEY'),
    'region'   => env('AWS_DEFAULT_REGION', 'us-east-1'),
    'token'    => env('AWS_SESSION_TOKEN'),
    'endpoint' => env('DYNAMODB_ENDPOINT'), // útil para local/testing
    'prefix'   => 'my-app-', // prefijo opcional para nombres de tabla
],
Enter fullscreen mode Exit fullscreen mode

Los valores de AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, y AWS_SESSION_TOKEN son inyectados automáticamente en el entorno a partir del rol de ejecución de la función. Son credenciales temporales que rotan solas, y los permisos que tienen son exactamente los que declaremos en IAM (sección 4.e).

provider:
  environment:
    DB_CONNECTION: dynamodb
Enter fullscreen mode Exit fullscreen mode

Y los modelos... siguen siendo modelos Eloquent, con un par de atributos extra para las claves de la tabla 15, y un poco de pegamento para el GSI:

use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Support\Str;
use Kitar\Dynamodb\Model\Model;

class User extends Model
{
    protected $table          = 'users';
    protected $primaryKey     = 'PK';     // partition key → USER#<uuid>
    protected $sortKey        = 'SK';     // sort key
    protected $sortKeyDefault = 'PROFILE';
    protected $fillable       = ['name', 'email', 'password'];
    protected $appends        = ['email'];  // para que aparezca al serializar

    protected static function booted(): void
    {
        static::creating(function (self $user) {
            $user->PK       = 'USER#'.Str::uuid();
            $user->GSI1PK   = 'USER'; // agrupa a todos los usuarios
        });
    }

    protected function email(): Attribute
    {
        // el email vive en GSI1SK: el mismo índice sirve para listar usuarios y para buscar por email
        return Attribute::make(
            get: fn (): string => $this->GSI1SK,
            set: static fn (string $email): array => [ 'GSI1SK' => $email ],
        );
    }
}
Enter fullscreen mode Exit fullscreen mode

Ojo con el "siguen siendo Eloquent": heredan mutators, casts, eventos, serialización y autenticación, pero no relaciones (hasMany(), belongsTo(), with()), ni where() genérico (acá es keyCondition(), filter() o condition()), ni orderBy() arbitrario (solo por Sort Key), ni paginate() por número de página (DynamoDB pagina por cursor), ni count()/agregados. No es limitación del paquete: es que DynamoDB no sabe hacer eso, y el paquete tiene la honestidad de no fingirlo.

¿Por qué un UUID y no el email como Partition Key, que es lo que hace el README del paquete? Porque en DynamoDB la clave primaria es la identidad del item: no se modifica, solo se borra y se vuelve a crear. El día que un usuario quiera cambiar su email, tendrían que recrear el item y todo lo que cuelgue de esa PK. Un identificador inmutable como PK y el email en un GSI les permite buscar por email hoy y cambiarlo mañana sin tocar la identidad del item.

El sortKeyDefault cubre el caso más común: User::find('USER#2aab…11a2') usa PROFILE como sort key automáticamente. Y el GSI resuelve los otros dos patrones de acceso:

// todos los usuarios
User::index('GSI1')->keyCondition('GSI1PK', '=', 'USER')->query();

// el usuario con este email
User::index('GSI1')
    ->keyCondition('GSI1PK', '=', 'USER')
    ->keyCondition('GSI1SK', '=', 'foo@bar.com')
    ->query()->first();
Enter fullscreen mode Exit fullscreen mode

Un detalle que muerde: el GSI permite buscar por email, pero no garantiza que sea único. Dos usuarios con el mismo email convivirían felices en el índice. Si necesitan unicidad, se valida antes de crear.

¿Ven esas claves raras? USER#<uuid> como clave primaria, USER metido en un índice GSI1... eso tiene nombre propio...

c) Single-Table Design: el concepto (y nada más)

Esas claves raras son la puerta de entrada al Single-Table Design: en lugar de una tabla por entidad (users, posts, comments...), varias entidades comparten una sola tabla diferenciándose por sus claves. La PK puede identificar el "dueño" del dato (USER#123), la SK qué cosa es (PROFILE, POST#456), y los GSIs les dan vistas alternativas para otros patrones de acceso.

¿Suena a magia negra? No lo es, pero sí es un arte: diseñar bien una tabla "single-table" requiere mapear todos los patrones de acceso antes de escribir una línea de código, algo que en SQL pueden improvisar sobre la marcha.

No voy a profundizar acá porque el tema merece su propio artículo (y lo tendrá). Hoy solo necesitan saber que existe, y que es la razón por la que DynamoDB puede reemplazar a una base relacional completa.

d) Cuándo DynamoDB le gana a SQL, y cuándo no

Seamos honestos, sin vender humo. DynamoDB es brutal cuando:

  • Conocen los patrones de acceso de antemano (get by id, list by owner, filter by status).
  • Necesitan latencia predecible: lecturas de un dígito de milisegundos, a cualquier escala 16.
  • El tráfico es impredecible: picos gigantes o nada de tráfico. PAY_PER_REQUEST: pagan por request, así que con tráfico casi nulo la factura es casi nula; con tráfico sostenido y alto, evalúen el modo provisionado 17.
  • Quieren escalar sin dramas: no hay nodo "master" que muera a las 4 AM, no hay réplicas de solo lectura que configurar para bypassear max_connections. La escalabilidad deja de ser un problema.
  • DynamoDB Streams 18: cada escritura puede disparar eventos. El equivalente al binlog de MySQL, pero administrado y capaz de ejecutar código.
  • Gestión cero: sin parches, sin VACUUM, sin mantenimiento programado.

Y no es para ustedes si:

  • Necesitan ordenar o filtrar por cualquier atributo: en DynamoDB solo se ordena por Sort Key y solo se busca eficientemente por claves (o GSIs). Todo lo demás es filter() sobre lo ya leído: pagan por leer y después descartan.
  • Necesitan JOINs y queries ad-hoc: "mostrame todos los usuarios que compraron X en el último mes agrupado por provincia" → háganlo en SQL o exporten a un data warehouse.
  • Dependen de UNIQUE, foreign keys o ON DELETE CASCADE: no existen. La unicidad se garantiza a mano con condition expressions (attribute_not_exists(PK)), y la integridad referencial es responsabilidad de su código, no de la base.
  • Sus modelos de datos cambian cada semana: rediseñar claves en DynamoDB duele más que una migración.
  • Dependen de reporting/analytics: dashboards, gráficos agregados, queries exploratorias → necesitan SQL. DynamoDB no es el lugar.
  • Necesitan almacenar ítems gigantes: DynamoDB tiene un máximo de 400KB por item 19. Los documentos grandes van en S3, y en DynamoDB solo la referencia.
  • Scan como estrategia 20: leen toda la tabla y pagan todo. Si la consulta se resuelve con scan, el diseño falló.

Patrones de acceso tipo «posts por usuario», «comentarios por post» o lecturas directas por ID encajan perfecto en el primer grupo. Casos de uso hechos a medida para DynamoDB.

e) La infraestructura también es código

Las tablas viven declaradas como recursos CloudFormation 21. La tabla del modelo User del ejemplo se vería así:

UsersTable:
  Type: AWS::DynamoDB::Table
  Properties:
    TableName: my-app-users
    BillingMode: PAY_PER_REQUEST
    AttributeDefinitions:
      - { AttributeName: PK,     AttributeType: S }
      - { AttributeName: SK,     AttributeType: S }
      - { AttributeName: GSI1PK, AttributeType: S }
      - { AttributeName: GSI1SK, AttributeType: S }
    KeySchema:
      - { AttributeName: PK, KeyType: HASH }
      - { AttributeName: SK, KeyType: RANGE }
    GlobalSecondaryIndexes:
      - IndexName: GSI1
        KeySchema:
          - { AttributeName: GSI1PK, KeyType: HASH }
          - { AttributeName: GSI1SK, KeyType: RANGE }
        Projection: { ProjectionType: ALL }
Enter fullscreen mode Exit fullscreen mode

Y los permisos IAM mínimos en el serverless.yml principal 22:

provider:
  iam:
    role:
      statements:
        - Effect: Allow
          Resource:
            - !GetAtt CacheTable.Arn
            - !GetAtt UsersTable.Arn
            - !Sub
              - '${Resource}/index/*'
              - { Resource: !GetAtt UsersTable.Arn }
            Action:
              - dynamodb:Query
              - dynamodb:GetItem
              - dynamodb:PutItem
              - dynamodb:UpdateItem
              - dynamodb:DeleteItem
Enter fullscreen mode Exit fullscreen mode

Si usan Cache::many() o Cache::getMultiple(), agreguen dynamodb:BatchGetItem: Laravel los resuelve en una sola llamada batch, y sin ese permiso van a recibir un AccessDeniedException que no menciona la palabra "batch" por ningún lado.

Sugerencia: Nunca debemos utilizar Action: dynamodb:* o Resource: *. Privilegio mínimo o nada 23.

f) Costos: la última factura fija se va

Actualicemos la cuenta:

  • La deuda del primer capítulo: Ahí quedó un RDS MySQL db.t4g.small que genera ~$26/mes (≈ $0.032/h × 730 h + almacenamiento 24) por una base de datos que cobra solo por existir. Hoy la retiramos.
  • Con DynamoDB: Podemos utilizar el modo BillingMode: PAY_PER_REQUEST y así solo pagar por request procesado y GB almacenado. Con tráfico modesto, la factura del mes se mide en centavos: la base de datos que cobraba por respirar dejó de existir, y ya ningún componente grande cobra tarifa plana por recursos que nadie usa.

5. ¿Qué Sigue?

Hoy resolvimos dónde persiste todo: archivos en S3 (con uploads que ni tocan Lambda), caché y sesiones en DynamoDB con expiración automática, y una base de datos NoSQL que habla Eloquent.

Pero el mapa todavía tiene zonas inexploradas. En el próximo artículo: las colas. Veremos cómo SQS + un worker Lambda reemplazan al queue:work que corría eternamente en un supervisor, y por qué eso es mejor que rezarle a supervisord a las 3 AM.


Una pregunta para ustedes: ¿ya usaron DynamoDB con Laravel, o siguen en el equipo MySQL/PostgreSQL? Cuéntenme en los comentarios qué los frena (o qué los enamoró) del mundo NoSQL.


  1. https://bref.sh/docs/environment/storage ↩

  2. https://github.com/getlift/lift/blob/master/docs/storage.md ↩

  3. https://laravel.com/framework/docs/13.x/filesystem#s3-driver-configuration ↩

  4. https://bref.sh/docs/laravel/file-storage ↩

  5. https://laravel.com/framework/docs/13.x/filesystem#temporary-upload-urls ↩

  6. https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#function-configuration-deployment-and-execution ↩

  7. https://bref.sh/docs/laravel/file-storage#uploading-files ↩

  8. https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html ↩

  9. https://laravel.com/framework/docs/13.x/cache#dynamodb ↩

  10. https://bref.sh/docs/environment/storage#deploying-dynamodb-tables ↩

  11. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html ↩

  12. https://laravel.com/framework/docs/13.x/session#configuration ↩

  13. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html ↩

  14. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html ↩

  15. https://github.com/kitar/laravel-dynamodb#extending-the-base-model ↩

  16. https://aws.amazon.com/blogs/database/understanding-amazon-dynamodb-latency/ ↩

  17. https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/capacity.html ↩

  18. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html ↩

  19. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-use-s3-too.html ↩

  20. https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-query-scan.html ↩

  21. https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-dynamodb-table.html ↩

  22. https://www.serverless.com/framework/docs/providers/aws/guide/iam ↩

  23. https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege ↩

  24. https://aws.amazon.com/rds/mysql/pricing/ ↩

Top comments (0)