Imagine you’re building a backend application that uses AWS S3 for file storage, SQS for messaging, DynamoDB for persistence, and Lambda for background processing.

Everything works during development until you need to test the actual cloud integrations.

You create an AWS account, configure credentials, set up cloud resources, deploy your application, and spend time cleaning up resources after every test. Your development workflow now depends on external infrastructure.

For a small feature, that’s a lot of overhead.

What if you could run these cloud services locally, connect your existing SDKs and CLIs to them, and test your application without touching a real cloud account?

That’s where local cloud emulators come in.

Developers have used tools such as LocalStack, Moto, and Azurite for years to emulate individual cloud services. However, a newer open-source project called Floci is taking a broader approach: providing local emulators for AWS, Microsoft Azure, Google Cloud Platform, and Oracle Cloud Infrastructure.

Let’s look at how it works, what it supports, and how you can use it in your development workflow.

What are local cloud emulators?

A local cloud emulator recreates the API behavior of cloud services on your development machine.

Your application communicates with the emulator through an endpoint such as http://localhost:4566 instead of connecting to AWS infrastructure.

Your existing SDKs, CLI tools, and application code can interact with the local implementation.

Consider this architecture:

Traditional cloud development

Application
    |
    v
Cloud SDK
    |
    v
Internet
    |
    v
AWS / Azure / GCP
    |
    v
Cloud Resources

With a local cloud emulator:

Local cloud development

Application
    |
    v
Cloud SDK
    |
    v
localhost
    |
    v
Local Cloud Emulator
    |
    v
Local Services

This gives developers a way to test cloud-dependent application behavior without provisioning real cloud infrastructure for every development cycle.

There is an important distinction between mocking and emulation.

A mock generally returns predetermined responses or implements a limited interface for testing. An emulator accepts service-compatible requests and implements the corresponding API behavior, often maintaining resource state.

The depth of emulation depends on the service and the operations implemented.

Meet Floci: One open-source ecosystem for fourΒ clouds

GitHub: floci-io

Website: floci.io

Floci is an open-source local cloud emulator ecosystem designed for application development, testing, and CI.

Its approach is straightforward: run cloud-compatible services locally and connect your existing development tools to them.

The ecosystem currently contains four separate emulators.

Each emulator runs independently. You can start one provider or run multiple providers side by side.

The projects are available on GitHub:

Let’s look at what each emulator brings.

1. Floci: AWS local cloudΒ emulator

Floci is the AWS emulator in the ecosystem and an alternative to LocalStack.

It supports a broad range of AWS services, including:

Other supported services include Step Functions, CloudWatch, Route 53, ECR, and several analytics and AI services.

The interesting part is the approach to service implementation.

Some services use actual underlying engines. For example, Lambda executes functions in Docker containers, RDS uses real PostgreSQL and MySQL instances, and ElastiCache uses Redis-compatible infrastructure.

This gives developers more realistic behavior for those services than a simple collection of predetermined responses.

Floci exposes AWS services through a common endpoint:

http://localhost:4566

Your existing AWS SDKs and CLI commands can target this endpoint.

2. Floci AZ: Local AzureΒ emulator

GitHub: floci-az

Azure developers also get a dedicated local emulator.

Floci AZ supports services such as:

  • Blob, Queue, and Table Storage

  • Cosmos DB

  • Azure Functions

  • Key Vault

  • Event Hubs

  • Service Bus

  • Azure SQL Database

  • Azure Kubernetes Service

It provides a common local endpoint:

http://localhost:4577

One useful feature is compatibility with existing Azure development tools.

You can configure your Azure SDK, Azure CLI, or Terraform provider to communicate with the local emulator.

For developers already familiar with Azurite, Floci AZ also provides a wider set of Azure services beyond the storage services that Azurite focuses on.

This makes it worth investigating when your application depends on multiple Azure services.

3. Floci GCP: Local Google CloudΒ emulator

GitHub: floci-gcp

Google Cloud developers get their own emulator through Floci GCP.

Some supported services include:

  • Cloud Storage

  • Pub/Sub

  • Firestore

  • Datastore

  • Secret Manager

  • IAM

  • Managed Kafka

The local endpoint is:

http://localhost:4588

You can use supported GCP SDKs and gcloud CLI commands against this endpoint.

For example, creating a local storage bucket can use the familiar Google Cloud command:

gcloud storage buckets create gs://demo-bucket

This is useful when developing event-driven applications that rely on Google Cloud Storage, Pub/Sub, and other supported services.

4. Floci OCI: Local Oracle CloudΒ emulator

GitHub: floci-oci

Oracle Cloud Infrastructure is another provider included in the ecosystem.

Floci OCI supports several OCI services:

  • Object Storage

  • Queue

  • Streaming

  • Identity and compartments

  • Vault and Key Management

  • Secrets

  • Functions

  • Container Engine for Kubernetes

The local endpoint is:

http://localhost:4599

It works with the OCI CLI, supported OCI SDKs, Terraform, and OpenTofu.

One interesting detail is that OCI request compatibility includes features such as OCIDs, pagination headers, ETags, work requests, and OCI-compatible error responses.

For developers working with Oracle Cloud, having a local environment for these integrations can reduce dependency on an actual OCI tenancy during development.

πŸ’‘ Enjoying this article?
Every week day, I publish practical, production-ready deep dives covering Web development, System Design, Open source projects, Tech industry trends and AI Engineering and tools.

Getting started withΒ Floci

You don’t need to manually configure every container and environment variable.

Floci provides an official CLI that manages the emulator lifecycle.

Step 1: Install FlociΒ CLI

On macOS or Linux with Homebrew:

brew install floci-io/floci/floci

You can also install it using the installation script:

curl -fsSL https://floci.io/install.sh | sh

Repository: floci-cli

Step 2: Start your local AWS environment

Run:

floci start

The CLI pulls the required Docker image if necessary, starts the emulator, and waits for it to become ready.

Step 3: Configure AWSΒ CLI

Execute:

eval "$(floci env)"

This configures the environment variables needed to communicate with the local AWS emulator.

Step 4: Create your first S3Β bucket

Now use your existing AWS CLI commands:

aws s3 mb s3://demo-bucket

aws s3 ls

That’s it. You have created an S3 bucket against your local emulator.

Your application can use its normal AWS SDK configuration, pointing requests at the local endpoint.

Step 5: Try other cloud providers

The CLI exposes separate commands for each provider.

# Google Cloud
floci gcp start
eval "$(floci gcp env)"

# Azure
floci az start
floci az setup
eval "$(floci az env)"

# Oracle Cloud
floci oci start
floci oci setup
eval "$(floci oci env)"

You can also run the emulator with persistent local storage:

floci start --persist ./data

Useful lifecycle commands include:

floci status
floci logs
floci stop

The CLI manages emulator containers and configuration. Your regular cloud CLI tools remain responsible for creating and managing cloud resources.

Two additional projects worth exploring

The Floci ecosystem includes supporting tools beyond the four emulators.

Floci UI: Manage resources through aΒ browser

GitHub: floci-ui

Working entirely through the terminal becomes inconvenient when you have several local resources to inspect.

Floci UI provides a browser-based console for AWS, Azure, GCP, and OCI.

You can launch the multi-cloud environment using:

docker compose --profile multicloud up

Then open:

http://localhost:4500

One architectural detail is worth mentioning: Floci UI does not emulate cloud services itself. Its API sends requests through the cloud SDKs to the emulators, and the interface displays the responses returned by those services.

That means the UI reflects actual emulator responses rather than generating demonstration resource records.

Floci Duck: SQL execution usingΒ DuckDB

GitHub: floci-duck

Floci Duck is an additional component for developers working with data and analytics.

It uses DuckDB as its SQL execution engine and supports S3-compatible storage through its HTTP filesystem extension.

Some of its capabilities include:

  • Athena-style query execution with CSV results exported to S3.

  • Firehose-style SQL execution.

  • S3 Select-style queries returning JSON.

  • Reading and writing Parquet files directly to S3.

It is particularly relevant when your local application uses AWS analytics services and you need to exercise SQL-based workflows.

What should developers consider before using cloud emulators?

Local cloud emulators can make development much easier, but there are a few engineering considerations.

1. Check API compatibility service by service.

An emulator can advertise support for a service while implementing only a subset of its operations. Check the actual compatibility documentation for the operations your application uses.

2. Understand authentication differences.

Floci is designed to work without real cloud credentials. For example, its AWS setup can accept non-empty test credentials. This is convenient locally, but authentication behavior may differ from production IAM and identity policies.

3. Be careful with Docker socket access.

Some services need Docker access to launch containers for workloads such as Lambda. Mounting the Docker socket gives the emulator control over the host container daemon. Use this only in an environment where that access is appropriate.

4. Keep integration tests against the real cloud.

Local emulation cannot guarantee identical behavior for every managed service, IAM policy, quota, networking configuration, or regional feature.

Use local emulators for rapid feedback and repeatable development. Keep a separate integration-testing stage against the actual cloud provider before production deployments.

Final thoughts

Local cloud emulation is becoming an increasingly useful part of modern development workflows.

For developers working with AWS, Azure, GCP, or OCI, Floci offers an interesting open-source ecosystem worth exploring. Having separate provider emulators with a shared CLI and browser console makes it easier to experiment with cloud services without provisioning a real cloud environment for every development task.

I’d start with one provider and the services your application actually needs. Get the SDK integration working, add the emulator to your local Docker workflow, and then introduce it into CI.

You can explore the complete ecosystem here:

GitHub: Floci-IO

Website: Floci

Thank You forΒ Reading!

I hope you found it helpful and informative. If you have any questions or feedback, feel free to leave a comment below. Your support and engagement mean a lot to me.

Happy Coding!

Reply

Avatar

or to participate

Avatar

sriram2 days ago

Great info. There is always something to learn from your articles. I never feel like i lost time reading your article.

Avatar

Vijayasekhar DeepakAuthor2 days ago

Thank you