oblako

oblako is a local AWS platform: run Bedrock, SageMaker, Redshift, Step Functions and more on your laptop, no cloud required. You write the AWS code you already write, every service maps 1:1 to a boto3 client, and oblako runs it against real local engines wired into an AWS-shaped topology.

import boto3

s3 = boto3.client("s3")          # -> S3Proxy, real S3 API over the filesystem
s3.create_bucket(Bucket="demo")

ddb = boto3.client("dynamodb")   # -> DynamoDB Local
ddb.list_tables()

The difference from a mock: a bucket really stores bytes, a redshift-connector session really runs SQL, a SageMaker job really trains in a container. oblako simulates the topology (clusters, endpoints, control planes) around engines that are doing the work. Real behavior, simulated topology.

Documentation → · oblako on GitHub →

Quick start

oblako needs Python 3.10 or later and a container runtime: Docker (the default), Podman, Colima, or Apple’s container. Most services run as containers. A few API engines run in Python without one.

pip install oblako         # or: uv tool install oblako

oblako up                  # start the services
oblako configure           # write the `oblako` AWS profile
export AWS_PROFILE=oblako  # point boto3 and the AWS CLI at oblako
oblako dashboard           # web UI at http://localhost:8000

Your unmodified boto3 code and the AWS CLI then reach the local services, with no endpoint_url in the code. Select another AWS profile and the same code talks to AWS.

Extras

Optional dependencies for specific workloads:

Extra	Adds
`oblako[sagemaker]`	The SageMaker SDK v3, for code that drives it against oblako and for its local modes
`oblako[mlflow]`	A local MLflow tracking server
`oblako[iceberg]`	`pyiceberg` for reading and writing tables through the local Iceberg catalog
`oblako[parquet]`	Firehose record format conversion from JSON to Parquet
`oblako[mysql]`	The MySQL driver for RDS MySQL
`oblako[agentcore]`	The `bedrock-agentcore` SDK for local AgentCore agents
`oblako[notebook]`	JupyterLab for `oblako notebook`

pip install "oblako[sagemaker,parquet]"

What runs locally

Each service is a real engine on a fixed local port, reached by the same boto3 client (or native driver) you’d use in the cloud.

Data and analytics services: S3, Glue, Redshift, Athena, Kinesis, Firehose, RDS, DynamoDB

Containers and compute: ECS, Fargate, EKS, ECR, Lambda, Step Functions

AWS service	Local replacement	How
Bedrock (LLMs)	Ollama (or OpenRouter)	boto3 `bedrock-runtime` invoke and converse. The OpenRouter backend hits real models with your key
Bedrock (control plane)	oblako server	boto3 `bedrock`: foundation-model catalog and batch model-invocation jobs
Bedrock Knowledge Bases	OpenSearch	Vector search with k-NN
Bedrock AgentCore (Runtime)	bedrock-agentcore SDK	Local agent on the `/invocations` and `/ping` contract
SageMaker	oblako engine + SDK v3 local mode	boto3 `sagemaker` runs jobs and endpoints in real Docker. `ModelTrainer` / `ModelBuilder` local mode runs with no account
Step Functions	aws-stepfunctions-local	Official AWS Docker image
Lambda	AWS SAM CLI (external)	`sam local invoke`, bring your own SAM CLI
ECS / Fargate	moto + container per task	`run_task` / `create_service` launch real containers. A Fargate + ALB CloudFormation stack deploys and serves locally
ELBv2 (ALB)	moto + Caddy proxy per LB	Real reverse proxy round-robining to tasks with the target group health check
S3	S3Proxy	S3 API over the local filesystem
S3 Tables	oblako server + Iceberg REST catalog	boto3 `s3tables`. Tables are real Iceberg, queryable by Athena, Trino and pyiceberg
S3 Vectors	oblako server	boto3 `s3vectors`: vector buckets, indexes and k-NN `QueryVectors`
DynamoDB	dynamodb-local	Official AWS Docker image
Kinesis	kinesalite	Kinesis Data Streams
Firehose	oblako server	boto3 `firehose` delivery streams, buffered and flushed to S3 or Redshift
Athena	oblako server + Trino	boto3 `athena`. Queries run on Trino, results go to the S3 output location
Redshift (engine)	oblako image (PostgreSQL 16)	Impersonates Redshift: redshift-connector natively, system tables, `SET query_group`, UDFs
Redshift (management API)	moto	boto3 `redshift` control plane: clusters, nodes, endpoints
Redshift Data API	oblako server	boto3 `redshift-data`, real SQL against the engine
Redshift ML	Training container + plpython3u	`CREATE MODEL` from any SQL client, trained asynchronously in a container. The prediction function runs in-DB
RDS / Aurora	moto + PostgreSQL / MySQL	boto3 `rds` control plane and a real engine
RDS Data API	oblako server	boto3 `rds-data`: synchronous SQL and transactions
CloudFormation	oblako server	boto3 `cloudformation` (and `aws cloudformation deploy` / `sam deploy`) creates real oblako resources
Glue	Spark + S3Proxy	Spark jobs read and write oblako’s S3
Glue Data Catalog	oblako server	boto3 `glue` databases, tables, partitions and crawlers. It is Athena’s `AwsDataCatalog`
MWAA (Airflow)	AWS’s MWAA Airflow image	boto3 `mwaa`. Each environment runs real Airflow, with DAGs synced from S3
EventBridge	moto + oblako proxy	boto3 `events`. Scheduled rules fire and run their targets
EKS	moto	boto3 `eks` control plane: create, describe and list clusters
API Gateway	AWS SAM CLI (external)	`sam local start-api`, bring your own SAM CLI
AppConfig	oblako agent	Python reimplementation of the feature-flag and A/B split

Per-service guides and limitations are in the services documentation.

CLI

Command	Description
`oblako up [service]`	Start all services, or one, and wait for each to be ready. Exits 1 if any is not, so a CI step fails there
`oblako down [service]`	Stop all services, or one
`oblako status`	Show service status
`oblako configure`	Write an `oblako` AWS profile whose per-service endpoints are oblako’s. Other profiles are left as they are
`oblako dashboard`	Start the web dashboard on `127.0.0.1:8000`
`oblako notebook`	Launch JupyterLab wired to oblako
`oblako logs <service>`	Show logs for a service
`oblako pull [model]`	Pull a model into the Bedrock engine

The full command list is in the quick start guide.

Container runtimes

oblako isn’t hard-wired to Docker. Every service runs through a pluggable backend, selected with OBLAKO_CONTAINER_BACKEND: docker (default), podman, colima, kubernetes, or Apple’s container (apple). See the runtimes guide.

The book

A Data Guide to AWS on oblako walks through the AWS data services as they run on oblako, chapter by chapter, with code you can run: S3, Glue and Athena, Redshift, RDS, DynamoDB, streaming, Spark with Iceberg, MWAA, testing in CI, and moving to AWS.

Read it online → · Download the PDF →

Documentation

Service guides, architecture, the dashboard, container runtimes, and the Python API reference live at oblako-sdk.almostly.ai.

License

oblako is open core. The open-source edition is licensed under the Apache License 2.0. Commercial Pro and hosted editions are offered separately under their own terms.

oblako orchestrates third-party engines (moto, S3Proxy, Trino, Postgres, and others) that it pulls at runtime rather than redistributing. Each keeps its own license, inventoried in THIRD_PARTY_LICENSES.md.