Services on DevCloud

Mon, 01 Jan 0001 00:00:00 +0000

DynamoDB

Overview

DevCloud DynamoDB uses BadgerDB as its embedded key-value storage backend. Table metadata is kept in an in-memory index (protected by RWMutex), while items are persisted in BadgerDB with composite keys (_item/{table}#{partitionKey}#{sortKey}).

Supported attribute types: S (String), N (Number), B (Binary), BOOL, NULL, L (List), M (Map).

Supported APIs

Operation	Description
CreateTable	Create table with partition key (HASH) and optional sort key (RANGE)
DeleteTable	Delete table and all its items
ListTables	List all table names
PutItem	Insert or overwrite an item
GetItem	Retrieve an item by primary key
DeleteItem	Delete an item by primary key
Query	Query items by partition key
Scan	Full table scan

boto3 Examples

Create a table and write items

import boto3

dynamodb = boto3.client(
 "dynamodb",
 endpoint_url="http://localhost:4747",
 aws_access_key_id="test",
 aws_secret_access_key="test",
 region_name="us-east-1",
)

# Create table
dynamodb.create_table(
 TableName="users",
 KeySchema=[
 {"AttributeName": "pk", "KeyType": "HASH"},
 {"AttributeName": "sk", "KeyType": "RANGE"},
 ],
 AttributeDefinitions=[
 {"AttributeName": "pk", "AttributeType": "S"},
 {"AttributeName": "sk", "AttributeType": "S"},
 ],
 BillingMode="PAY_PER_REQUEST",
)

# Put item
dynamodb.put_item(
 TableName="users",
 Item={
 "pk": {"S": "user#123"},
 "sk": {"S": "profile"},
 "name": {"S": "Alice"},
 "age": {"N": "30"},
 },
)

# Get item
response = dynamodb.get_item(
 TableName="users",
 Key={"pk": {"S": "user#123"}, "sk": {"S": "profile"}},
)
print(response["Item"])

Query and scan

# Query by partition key
response = dynamodb.query(
 TableName="users",
 KeyConditionExpression="pk = :pk",
 ExpressionAttributeValues={":pk": {"S": "user#123"}},
)
for item in response["Items"]:
 print(item)

# Full table scan
response = dynamodb.scan(TableName="users")
for item in response["Items"]:
 print(item)

AWS CLI Examples

# Create table
aws --endpoint-url http://localhost:4747 dynamodb create-table \
 --table-name my-table \
 --key-schema AttributeName=pk,KeyType=HASH \
 --attribute-definitions AttributeName=pk,AttributeType=S \
 --billing-mode PAY_PER_REQUEST

# Put item
aws --endpoint-url http://localhost:4747 dynamodb put-item \
 --table-name my-table \
 --item '{"pk": {"S": "key1"}, "data": {"S": "value1"}}'

# Get item
aws --endpoint-url http://localhost:4747 dynamodb get-item \
 --table-name my-table \
 --key '{"pk": {"S": "key1"}}'

Known Limitations

No UpdateItem (use PutItem to overwrite entire item)
No batch operations (BatchGetItem, BatchWriteItem)
No transactions (TransactGetItems, TransactWriteItems)
No secondary indexes (GSI/LSI)
No DynamoDB Streams
No advanced filter expressions on Query/Scan
No projection expressions
No conditional writes (ConditionExpression)
No TTL

Mon, 01 Jan 0001 00:00:00 +0000

IAM / STS

Overview

DevCloud IAM and STS share a single SQLite database (WAL mode). IAM manages users, roles, and access keys. STS generates temporary credentials and caller identity information.

Both services use the Query protocol (form-encoded requests, XML responses).

Supported IAM APIs

Operation	Description
CreateUser	Create an IAM user
ListUsers	List all IAM users
CreateRole	Create an IAM role with assume role policy document
ListRoles	List all IAM roles
AttachRolePolicy	Attach a managed policy ARN to a role
CreateAccessKey	Generate an access key pair for a user

Supported STS APIs

Operation	Description
GetCallerIdentity	Return account ID, ARN, and user ID
AssumeRole	Generate temporary credentials (ASIA-prefixed keys, 1-hour expiry)
GetSessionToken	Generate MFA-backed session credentials

boto3 Examples

IAM: Create users and roles

import boto3

iam = boto3.client(
 "iam",
 endpoint_url="http://localhost:4747",
 aws_access_key_id="test",
 aws_secret_access_key="test",
 region_name="us-east-1",
)

# Create user
iam.create_user(UserName="testuser")

# Create access key for user
keys = iam.create_access_key(UserName="testuser")
print(keys["AccessKey"]["AccessKeyId"])
print(keys["AccessKey"]["SecretAccessKey"])

# Create role
iam.create_role(
 RoleName="lambda-role",
 AssumeRolePolicyDocument='{"Version":"2012-10-17","Statement":[]}',
)

# List users and roles
for user in iam.list_users()["Users"]:
 print(user["UserName"])
for role in iam.list_roles()["Roles"]:
 print(role["RoleName"])

STS: Get caller identity and assume role

sts = boto3.client(
 "sts",
 endpoint_url="http://localhost:4747",
 aws_access_key_id="test",
 aws_secret_access_key="test",
 region_name="us-east-1",
)

# Get caller identity
identity = sts.get_caller_identity()
print(identity["Account"]) # 000000000000
print(identity["Arn"])

# Assume role
response = sts.assume_role(
 RoleArn="arn:aws:iam::000000000000:role/lambda-role",
 RoleSessionName="my-session",
)
creds = response["Credentials"]
print(creds["AccessKeyId"]) # ASIA-prefixed
print(creds["SecretAccessKey"])
print(creds["SessionToken"])
print(creds["Expiration"]) # 1 hour from now

AWS CLI Examples

# Create user
aws --endpoint-url http://localhost:4747 iam create-user --user-name testuser

# Create access key
aws --endpoint-url http://localhost:4747 iam create-access-key --user-name testuser

# Get caller identity
aws --endpoint-url http://localhost:4747 sts get-caller-identity

# Assume role
aws --endpoint-url http://localhost:4747 sts assume-role \
 --role-arn arn:aws:iam::000000000000:role/my-role \
 --role-session-name my-session

Known Limitations

IAM:

Mon, 01 Jan 0001 00:00:00 +0000

Lambda

Overview

DevCloud Lambda stores function metadata in SQLite and function code (ZIP files) on the filesystem. Function registration and management are fully supported, but code execution is currently a stub — invoking a function returns a placeholder response instead of running the actual code.

Supported APIs

Operation	Description
CreateFunction	Create function with base64-encoded ZIP code
ListFunctions	List all functions in the account
GetFunction	Get function metadata and code location
DeleteFunction	Delete a function
UpdateFunctionCode	Update function code ZIP
Invoke	Invoke function (stub — returns placeholder response)

boto3 Examples

Create and manage functions

import boto3
import zipfile
import io
import base64

lambda_client = boto3.client(
 "lambda",
 endpoint_url="http://localhost:4747",
 aws_access_key_id="test",
 aws_secret_access_key="test",
 region_name="us-east-1",
)

# Create a ZIP file with handler code
zip_buffer = io.BytesIO()
with zipfile.ZipFile(zip_buffer, "w") as zf:
 zf.writestr("index.py", 'def handler(event, context): return {"statusCode": 200}')
zip_buffer.seek(0)

# Create function
lambda_client.create_function(
 FunctionName="my-func",
 Runtime="python3.12",
 Handler="index.handler",
 Role="arn:aws:iam::000000000000:role/lambda-role",
 Code={"ZipFile": zip_buffer.read()},
)

# List functions
response = lambda_client.list_functions()
for fn in response["Functions"]:
 print(fn["FunctionName"], fn["Runtime"])

# Get function details
response = lambda_client.get_function(FunctionName="my-func")
print(response["Configuration"]["FunctionArn"])

Invoke function (stub)

import json

response = lambda_client.invoke(FunctionName="my-func", Payload=json.dumps({"key": "value"}))
print(json.loads(response["Payload"].read()))
# {"statusCode": 200, "body": "Lambda invoke requires Docker runtime"}

AWS CLI Examples

# Create function
aws --endpoint-url http://localhost:4747 lambda create-function \
 --function-name my-func \
 --runtime python3.12 \
 --handler index.handler \
 --role arn:aws:iam::000000000000:role/role \
 --zip-file fileb://code.zip

# List functions
aws --endpoint-url http://localhost:4747 lambda list-functions

# Invoke (returns stub response)
aws --endpoint-url http://localhost:4747 lambda invoke \
 --function-name my-func output.json

Known Limitations

No code execution — Invoke returns a placeholder response. Docker runtime integration is planned but not yet implemented.
No layers
No aliases or versions
No event source mappings
No concurrency controls
No function URLs
No resource-based policies
No environment variables support

Mon, 01 Jan 0001 00:00:00 +0000

S3 (Simple Storage Service)

Overview

DevCloud S3 provides basic object storage using the filesystem for object data and SQLite for metadata. Objects are stored as files on disk; bucket and object metadata (names, sizes, ETags, content types, timestamps) are tracked in a SQLite database with WAL mode enabled.

Supported APIs

Operation	Description
ListBuckets	List all buckets in the account
CreateBucket	Create a new bucket
DeleteBucket	Delete an empty bucket
ListObjects	List objects in a bucket (supports prefix filtering)
PutObject	Upload an object (computes MD5 ETag)
GetObject	Download an object with metadata headers
HeadObject	Retrieve object metadata without body
DeleteObject	Delete an object from a bucket

boto3 Examples

Create a bucket and upload an object

import boto3

s3 = boto3.client(
 "s3",
 endpoint_url="http://localhost:4747",
 aws_access_key_id="test",
 aws_secret_access_key="test",
 region_name="us-east-1",
)

# Create bucket
s3.create_bucket(Bucket="my-bucket")

# Upload object
s3.put_object(Bucket="my-bucket", Key="hello.txt", Body=b"Hello, DevCloud!")

# Download object
response = s3.get_object(Bucket="my-bucket", Key="hello.txt")
print(response["Body"].read().decode()) # Hello, DevCloud!

List buckets and objects

# List all buckets
buckets = s3.list_buckets()
for b in buckets["Buckets"]:
 print(b["Name"])

# List objects in a bucket
objects = s3.list_objects(Bucket="my-bucket", Prefix="hello")
for obj in objects.get("Contents", []):
 print(obj["Key"], obj["Size"])

AWS CLI Examples

# Create bucket
aws --endpoint-url http://localhost:4747 s3 mb s3://my-bucket

# Upload file
aws --endpoint-url http://localhost:4747 s3 cp file.txt s3://my-bucket/

# List objects
aws --endpoint-url http://localhost:4747 s3 ls s3://my-bucket/

# Download file
aws --endpoint-url http://localhost:4747 s3 cp s3://my-bucket/file.txt ./downloaded.txt

Known Limitations

No multipart upload support (CreateMultipartUpload, UploadPart, CompleteMultipartUpload)
No object versioning or object lock
No ACL or bucket policy management
No encryption (SSE-S3, SSE-KMS)
No CORS configuration
No lifecycle policies
No replication
No presigned URLs
Single account model (account ID: 000000000000)

Mon, 01 Jan 0001 00:00:00 +0000

SQS (Simple Queue Service)

Overview

DevCloud SQS provides in-memory message queues. Queues are stored in memory with thread-safe access (sync.RWMutex). Data is not persisted — all queues and messages are lost on server restart.

SQS supports dual protocol: legacy Query protocol (form-encoded with XML responses) and modern JSON 1.0 protocol (used by boto3 1.42+). The protocol is auto-detected based on the Content-Type header.

Supported APIs

All 23 SQS operations are handled over the JSON 1.0 protocol.