# Floci vs LocalStack: emular AWS en local sin cuenta ni token, y qué revisar antes de migrar

**URL:** https://www.yodev.dev/t/floci-vs-localstack-emular-aws-en-local-sin-cuenta-ni-token-y-que-revisar-antes-de-migrar/5453
**Category:** Desarrollo
**Tags:** devops, aws, open-source, testing, localstack, docker, testcontainers
**Created:** [22 Septiembre, 2026 14:56 UTC](https://www.yodev.dev/t/floci-vs-localstack-emular-aws-en-local-sin-cuenta-ni-token-y-que-revisar-antes-de-migrar/5453 "2026-09-22T14:56:52Z")
**Posts on this page:** 1
**Page:** 1

<div class="post-metadata">

### Author: ![Devy](https://yyz1.discourse-cdn.com/flex009/user_avatar/www.yodev.dev/devy/32/62_2.png) [@Devy](https://www.yodev.dev/u/Devy)
#### Post date: [22 Septiembre, 2026 14:56 UTC](https://www.yodev.dev/t/floci-vs-localstack-emular-aws-en-local-sin-cuenta-ni-token-y-que-revisar-antes-de-migrar/5453/1 "2026-09-22T14:56:52Z")

</div>

Floci es un emulador de AWS local, gratuito y con licencia MIT, que sirve las APIs de AWS en `localhost:4566` sin cuenta, sin token y sin funciones bloqueadas. Eso lo convierte en una alternativa directa a LocalStack, que desde marzo de 2026 exige un auth token para su imagen `latest`. Si Floci puede reemplazar a LocalStack en _tu_ pipeline es otra pregunta: depende de qué operaciones llaman tus tests, no de cuántos logos de servicios muestra el README.

> **Nota de investigación:** este artículo se basa en la documentación de Floci, sus notas de versión y su README, además del anuncio público de LocalStack. En yoDEV no instalamos Floci, no ejecutamos una migración ni reprodujimos ningún benchmark. Las versiones y condiciones de planes son las vigentes al 22 de septiembre de 2026.

## ¿Qué es Floci?

Floci es un emulador open source que ejecuta las APIs de AWS en local para desarrollo, testing y CI. Apuntas tu AWS CLI, tu SDK, Terraform, CDK u OpenTofu a `http://localhost:4566` y los usas como siempre. Al momento de publicar esta nota, la última versión es la 2.1.0, publicada el 15 de septiembre de 2026, con imágenes Docker para amd64 y arm64.

Floci ofrece cada servicio de una de tres formas:

- **Dentro del proceso.** Servicios como S3, SQS, SNS, DynamoDB, IAM y KMS los emula Floci directamente.
- **Contenedores reales de respaldo.** Lambda, RDS, ElastiCache, MSK, ECS, EKS y OpenSearch levantan contenedores Docker reales, como Postgres, Valkey o Redpanda. Tienes un motor de base de datos real, pero no el servicio gestionado de AWS que lo rodea.
- **Stubs.** Bedrock Runtime, Textract y Transcribe devuelven respuestas ficticias o predefinidas. Que un servicio de IA aparezca en la lista no significa inferencia de modelos en local.

Esa división importa más que cualquier conteo de servicios en un titular. La referencia canónica es la [matriz de servicios](https://floci.io/floci/services/), que detalla las operaciones soportadas por servicio.

## ¿Floci o LocalStack?

Elige según los tests en los que necesitas confiar, no según un gráfico de velocidad. Esto es lo que respalda la documentación:

| | Floci | LocalStack (distribución unificada) |
| --- | --- | --- |
| Cuenta / auth token | No se requiere | Requerido para `latest` desde marzo de 2026 |
| Licencia | MIT | Plan gratuito restringido a uso no comercial |
| Actualizaciones | Versiones activas (2.1.0, 15 de septiembre de 2026) | Las actualizaciones van a la imagen autenticada; las etiquetas antiguas de Community no reciben parches |
| Referencia de cobertura | Matriz de servicios por operación | La documentación de LocalStack |

El README de Floci también anuncia un arranque de unos 24 ms y 13 MiB de memoria en reposo, frente a 3,3 s y 143 MiB. Son **cifras del propio proveedor** , medidas contra la imagen congelada de LocalStack Community y no contra la distribución actual de LocalStack. No son una medición de tu carga de trabajo.

Si también estás evaluando otras _LocalStack alternatives_, cubrimos MiniStack por separado: [MiniStack: El Reemplazo Gratuito de LocalStack que la Comunidad Estaba Esperando](https://www.yodev.dev/t/ministack-el-reemplazo-gratuito-de-localstack-que-la-comunidad-estaba-esperando/2119).

## ¿LocalStack sigue siendo gratis?

Depende de cómo lo uses. Según el propio anuncio de LocalStack (publicado en diciembre de 2025 y actualizado en marzo de 2026), cambiaron varias cosas:

- Community y Pro se unificaron en una sola imagen, y ejecutar `latest` requiere un auth token.
- El plan gratuito está pensado para uso no comercial.
- Las etiquetas de versión antiguas de Community todavía corren sin autenticación, pero no reciben parches de seguridad.
- El repositorio de Community sigue público, con mantenimiento reducido.

Revisa la página de _LocalStack pricing_ vigente antes de decidir. Las condiciones cambian, y este artículo no cita precios.

## ¿Qué tests correr en local y cuáles en AWS real?

Corre en local lo que es barato equivocar y rápido de repetir:

- CRUD contra S3, SQS y DynamoDB
- Flujo de mensajes entre tus propios componentes
- `plan` y `apply` de IaC contra recursos desechables
- Entornos aislados por test en CI

Mantén verificaciones contra AWS real para el comportamiento que un emulador solo puede aproximar:

- Casos límite de autorización en IAM
- Redes de VPC, security groups y acceso entre cuentas
- Tiempos, reintentos y orden de entrega de eventos
- Cuotas de servicio, throttling y modos de fallo de los servicios gestionados

Que tus tests pasen contra Floci prueba que tu código funciona contra Floci. Su suite de compatibilidad (unos miles de tests automatizados entre SDKs y herramientas de IaC) solo cubre lo que esos tests verifican.

**Nota de Grego:** un emulador gratuito no es infraestructura sin costo. Alguien en tu equipo es dueño de la versión fijada, del tiempo de CI y de explicar por qué un test pasó en local y falló en AWS. Presupuesta eso antes de migrar, no lo descubras después.

## ¿Cómo instalar Floci?

El camino más rápido en la documentación oficial es Docker Compose. Fija la versión que estás evaluando en lugar de usar `latest`:

```yaml
services:
  floci:
    image: floci/floci:2.1.0
    ports:
      - "4566:4566"

```

```bash
docker compose up -d

```

Luego apunta tus herramientas de AWS a Floci con credenciales ficticias:

```bash
export AWS_ENDPOINT_URL=http://localhost:4566
export AWS_DEFAULT_REGION=us-east-1
export AWS_ACCESS_KEY_ID=test
export AWS_SECRET_ACCESS_KEY=test

```

La documentación sugiere agregar estas variables a tu perfil de shell. Nosotros recomendamos limitarlas a tu entorno de pruebas, para que un comando suelto nunca llegue a un endpoint real con supuestos equivocados.

Prueba rápida, tomada del quick start:

```bash
aws s3 mb s3://my-bucket --endpoint-url $AWS_ENDPOINT_URL
aws s3 ls --endpoint-url $AWS_ENDPOINT_URL

```

### ¿Cómo usar Floci con Testcontainers?

Para aislar cada test, Floci publica módulos de Testcontainers:

- **Java:** `io.floci:testcontainers-floci`
- **Node.js:** `@floci/testcontainers`
- **Python:** `testcontainers-floci`
- **.NET:** `Testcontainers.Floci`
- **Go:** figuraba como en desarrollo al momento de publicar esta nota.

Cada módulo levanta un contenedor de Floci nuevo por test y expone su endpoint y sus credenciales. En Python:

```bash
pip install testcontainers-floci

```

```python
import boto3
from floci import FlociContainer

def test_s3_create_bucket():
    with FlociContainer() as floci:
        s3 = boto3.client(
            "s3",
            endpoint_url=floci.get_endpoint(),
            region_name=floci.get_region(),
            aws_access_key_id=floci.get_access_key(),
            aws_secret_access_key=floci.get_secret_key(),
        )
        s3.create_bucket(Bucket="my-bucket")

```

## ¿Cómo migrar de LocalStack a Floci?

La guía de migración describe la mayoría de los casos como un simple cambio de imagen. Revisa cada uno de estos puntos contra tu propia configuración:

1. **Imagen.** Reemplaza `localstack/localstack` por `floci/floci:2.1.0`. Si tus scripts de inicio llaman a `aws` o `boto3`, usa `floci/floci:2.1.0-compat`, que incluye la AWS CLI y boto3.
2. **Variables de entorno.** Floci traduce automáticamente variables de LocalStack como `LOCALSTACK_HOST`, `PERSISTENCE` y `LAMBDA_DOCKER_NETWORK`. Define `LOCALSTACK_PARITY=false` para desactivar esa traducción.
3. **Scripts de inicio.** Los scripts en `/etc/localstack/init/` se ejecutan sin cambios.
4. **Directorio de estado.** LocalStack guarda los datos en `/var/lib/localstack`; Floci usa `/app/data`, así que actualiza tus volúmenes.
5. **Health checks.** `/_localstack/health` y `/_localstack/init` siguen disponibles. El log además termina con una línea `Ready.` al estilo de LocalStack, así que la estrategia de espera por defecto de `LocalStackContainer` en Testcontainers sigue funcionando.
6. **Diferencias conocidas.** `LAMBDA_REMOTE_DOCKER` no está soportado, la selección con `SERVICES` se ignora (arrancan todos los servicios) y Lambda siempre corre en Docker.
7. **Comportamiento, no solo arranque.** Vuelve a correr tu suite. Presta atención a la resolución de endpoints, la persistencia entre reinicios y los caminos de error, no solo al caso feliz.

## ¿Es seguro montar el socket de Docker?

Es un acceso potente al host, y conviene tratarlo así. Los servicios respaldados por contenedores reales (Lambda, RDS, ElastiCache y otros) necesitan montar `/var/run/docker.sock` dentro de Floci. Cualquier proceso con acceso a ese socket puede controlar Docker en el host. Algunas reglas prácticas:

- Móntalo solo si necesitas servicios respaldados por contenedores.
- Mantén el listener en local.
- Usa datos desechables y credenciales ficticias.
- No expongas esta configuración a cargas de CI no confiables.

El contenedor de Floci corre por defecto con un usuario sin privilegios. Según la documentación de configuración de Docker, `FLOCI_RUN_AS_ROOT=true` es solo para hosts donde el socket es accesible únicamente para root.

## ¿Conviene migrar a Floci?

Floci elimina la fricción de cuenta y token en los tests locales de AWS, y su ritmo de versiones es activo. Aun así, la decisión se reduce a un inventario: lista las operaciones exactas que llama tu aplicación, compáralas con la matriz de servicios y corre tu propia suite sobre una versión fijada antes de cambiar tu CI.

> **[GitHub - floci-io/floci: Light, fluffy, and always free - The AWS Local...](https://github.com/floci-io/floci)**
>
> Light, fluffy, and always free - The AWS Local Emulator alternative