Learn LocalStack - Advanced Services

#Introduction

In episode 15 we established the security rules: synthetic data, workspace isolation, and deliberate PERSISTENCE management. Now it's time to step out of the comfort zone of S3, DynamoDB, and Lambda. LocalStack doesn't stop at core services — it emulates compute, streaming, database, and analytics services. This episode explores the Advanced Services most used in the real world: ECS, EKS, Step Functions, Kinesis, MSK, OpenSearch, RDS, Redshift, and Athena.

One thing to remember from the start: each service has a different emulation depth. Some work fully functionally, others are mere API mocks. Always check a service's documentation before relying on a specific feature.

#ECS: Tasks & Services

ECS emulates clusters, task definitions, and services. Interestingly, LocalStack runs tasks for real as Docker containers. The basic flow: create a cluster, register a task definition, then run it once with run-task or continuously with a service.

awslocal ecs create-cluster --cluster-name dev-cluster
awslocal ecs register-task-definition \
  --family worker \
  --network-mode awsvpc \
  --container-definitions '[
    {"name": "worker", "image": "alpine", "command": ["echo", "hello-ecs"]}
  ]'
awslocal ecs run-task --cluster dev-cluster --task-definition worker

Notice: the image from the task definition is genuinely pulled and run by Docker. This is great for testing container-to-container integration, but requires an active Docker daemon on the host.

For workloads that must keep running, use a service with a desired count:

awslocal ecs create-service \
  --cluster dev-cluster --service-name worker-svc \
  --task-definition worker --desired-count 1

#EKS: Clusters, Nodes, and Karpenter

For Kubernetes, LocalStack provides EKS control plane emulation. We can create clusters and nodegroups without needing a real Kubernetes cluster:

awslocal eks create-cluster --name dev-eks \
  --role-arn arn:aws:iam::000000000000:role/eks-role \
  --resources-vpc-config '{"subnetIds": ["subnet-1"]}'
awslocal eks create-nodegroup --cluster-name dev-eks \
  --nodegroup-name nodes --instance-types t3.small \
  --node-role arn:aws:iam::000000000000:role/eks-node-role

Since the 2026.07.0 release, LocalStack supports pod identity and Karpenter-based node joins — great for testing node provisioning and pod identity flows without touching a production Kubernetes cluster.

#Step Functions: State Machines & HTTP Tasks

Step Functions emulates state machines: Pass, Choice, Wait, Map, and Task. An interesting feature in the latest releases is HTTP Tasks via the arn:aws:states:::http:invoke resource — a state machine can call external APIs (including on localhost) through EventBridge Connections. Here's an example definition that calls a local HTTP service:

{
  "StartAt": "PanggilAPI",
  "States": {
    "PanggilAPI": {
      "Type": "Task",
      "Resource": "arn:aws:states:::http:invoke",
      "Parameters": {
        "ApiEndpoint": "http://host.docker.internal:5000/orders",
        "Method": "POST",
        "RequestBody": {"orderId.$": "$.orderId"}
      },
      "End": true
    }
  }
}

Deploy and execute:

awslocal stepfunctions create-state-machine \
  --name order-flow --definition file://state-machine.json \
  --role-arn arn:aws:iam::000000000000:role/sfn-role
awslocal stepfunctions start-execution \
  --state-machine-arn arn:aws:states:us-east-1:000000000000:stateMachine:order-flow \
  --input '{"orderId": "O-1001"}'

#Kinesis: Streams & Records

Kinesis Data Streams is emulated with shards and records. The basic flow:

awslocal kinesis create-stream --stream-name events --shard-count 1
awslocal kinesis put-record --stream-name events \
  --partition-key p1 --data aGVsbG8td29ybGQ=
awslocal kinesis describe-stream --stream-name events

Kinesis semantics — shards, sequence numbers, shard iterators — are preserved, so consumer patterns like KCL can be tested locally.

#MSK / Kafka

Managed Streaming for Apache Kafka is emulated by using a Kafka broker running inside the instance. Create a cluster, then work with topics:

awslocal kafka create-cluster-v2 \
  --cluster-name dev-msk --cluster-type PROVISIONED
awslocal kafka list-clusters-v2

For Kafka-level interactions (produce/consume), you can use kafka-console-producer directly or an SDK pointed at the local broker.

#OpenSearch: 3.3 and 3.5

LocalStack emulates OpenSearch domains on versions 3.3 and 3.5. We can create a domain, then do index CRUD:

awslocal opensearch create-domain \
  --domain-name logs --engine-version OpenSearch_3.3
awslocal opensearch list-domain-names

Once the domain is ready, indexes can be created via the REST API or an SDK. This is useful for testing search pipelines before production.

#RDS: PostgreSQL and Aurora DSQL

RDS PostgreSQL is emulated — LocalStack can even spin up a real PostgreSQL database inside the container:

awslocal rds create-db-instance \
  --db-instance-identifier dev-pg \
  --engine postgres --db-instance-class db.t3.micro \
  --master-username postgres --master-user-password password
awslocal rds describe-db-instances

Meanwhile Aurora DSQL, the PostgreSQL-compatible serverless database, has had CRUD and SQL dialect support since the 2026.07.0 release. Great for testing application patterns that target Aurora DSQL without touching the cloud.

#Redshift: Clusters & Queries

Redshift is emulated at the cluster level and partially on the data plane:

awslocal redshift create-cluster \
  --cluster-identifier dev-rs --node-type dc2.large \
  --number-of-nodes 1
awslocal redshift describe-clusters

Usually enough to test SDK calls and provisioning flows — not for running heavy OLAP queries.

#Athena: Federated Catalogs

Athena is emulated for creating workgroups and running simple queries. With a federated catalog, local Athena can read external data catalogs — for example mapping data in local S3 to a table schema:

awslocal athena create-work-group --name dev-wg \
  --configuration '{"ResultConfiguration": {"OutputLocation": "s3://results/"}}'
awslocal athena start-query-execution \
  --work-group dev-wg --query-string "SELECT * FROM sales LIMIT 10"

#Closing

Summary of LocalStack's advanced services:

• ECS and EKS emulate container/Kubernetes compute, even running real workloads.
• Step Functions supports HTTP Tasks via arn:aws:states:::http:invoke to call APIs from a state machine.
• Kinesis, MSK, OpenSearch, RDS, Redshift, and Athena are available with varying emulation depth.
• Check each service's official documentation before relying on a specific feature.

All these services test your code, not real infrastructure. In the next episode 17 we discuss AWS Replicator — the Pro feature that pulls resources from a real AWS account into LocalStack for far more realistic testing. See you there!