cloud-platforms

# Cloud Platforms ## Overview Cloud services, serverless architectures, and cloud-native development patterns for AWS, GCP, and Azure. --- ## AWS ### Lambda Functions ```typescript // lambda/handler.ts import { APIGatewayProxyHandler, APIGatewayProxyResult } from 'aws-lambda'; export const handler: APIGatewayProxyHandler = async (event) => { try { const body = JSON.parse(event.body || '{}'); // Business logic const result = await processRequest(body); return { statusCode: 200, headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', }, body: JSON.stringify(result), }; } catch (error) { console.error('Handler error:', error); return { statusCode: error.statusCode || 500, body: JSON.stringify({ error: error.message || 'Internal server error', }), }; } }; // With middleware (middy) import middy from '@middy/core'; import jsonBodyParser from '@middy/http-json-body-parser'; import httpErrorHandler from '@middy/http-error-handler'; import cors from '@middy/http-cors'; const baseHandler = async (event) => { // event.body is already parsed return { statusCode: 200, body: JSON.stringify({ data: event.body }), }; }; export const handler = middy(baseHandler) .use(jsonBodyParser()) .use(httpErrorHandler()) .use(cors()); ``` ### S3 Operations ```typescript import { S3Client, PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3'; import { getSignedUrl } from '@aws-sdk/s3-request-presigner'; const s3 = new S3Client({ region: process.env.AWS_REGION }); // Upload file async function uploadFile(key: string, body: Buffer, contentType: string) { await s3.send(new PutObjectCommand({ Bucket: process.env.S3_BUCKET, Key: key, Body: body, ContentType: contentType, })); return `https://${process.env.S3_BUCKET}.s3.amazonaws.com/${key}`; } // Generate presigned upload URL async function getUploadUrl(key: string, contentType: string, expiresIn = 3600) { const command = new PutObjectCommand({ Bucket: process.env.S3_BUCKET, Key: key, ContentType: contentType, }); return getSignedUrl(s3, command, { expiresIn }); } // Generate presigned download URL async function getDownloadUrl(key: string, expiresIn = 3600) { const command = new GetObjectCommand({ Bucket: process.env.S3_BUCKET, Key: key, }); return getSignedUrl(s3, command, { expiresIn }); } ``` ### DynamoDB ```typescript import { DynamoDBClient } from '@aws-sdk/client-dynamodb'; import { DynamoDBDocumentClient, PutCommand, GetCommand, QueryCommand, UpdateCommand, } from '@aws-sdk/lib-dynamodb'; const client = new DynamoDBClient({ region: process.env.AWS_REGION }); const docClient = DynamoDBDocumentClient.from(client); // Single table design patterns const TABLE_NAME = process.env.DYNAMODB_TABLE; // Put item async function createUser(user: User) { await docClient.send(new PutCommand({ TableName: TABLE_NAME, Item: { PK: `USER#${user.id}`, SK: `PROFILE#${user.id}`, GSI1PK: `EMAIL#${user.email}`, GSI1SK: `USER#${user.id}`, ...user, createdAt: new Date().toISOString(), }, ConditionExpression: 'attribute_not_exists(PK)', })); } // Get item async function getUser(userId: string) { const result = await docClient.send(new GetCommand({ TableName: TABLE_NAME, Key: { PK: `USER#${userId}`, SK: `PROFILE#${userId}`, }, })); return result.Item; } // Query with GSI async function getUserByEmail(email: string) { const result = await docClient.send(new QueryCommand({ TableName: TABLE_NAME, IndexName: 'GSI1', KeyConditionExpression: 'GSI1PK = :pk', ExpressionAttributeValues: { ':pk': `EMAIL#${email}`, }, })); return result.Items?.[0]; } // Update with conditions async function updateUserStatus(userId: string, status: string) { await docClient.send(new UpdateCommand({ TableName: TABLE_NAME, Key: { PK: `USER#${userId}`, SK: `PROFILE#${userId}`, }, UpdateExpression: 'SET #status = :status, updatedAt = :now', ConditionExpression: 'attribute_exists(PK)', ExpressionAttributeNames: { '#status': 'status', }, ExpressionAttributeValues: { ':status': status, ':now': new Date().toISOString(), }, })); } ``` ### SQS & SNS ```typescript import { SQSClient, SendMessageCommand, ReceiveMessageCommand } from '@aws-sdk/client-sqs'; import { SNSClient, PublishCommand } from '@aws-sdk/client-sns'; const sqs = new SQSClient({ region: process.env.AWS_REGION }); const sns = new SNSClient({ region: process.env.AWS_REGION }); // Send to SQS async function queueJob(job: Job) { await sqs.send(new SendMessageCommand({ QueueUrl: process.env.SQS_QUEUE_URL, MessageBody: JSON.stringify(job), MessageAttributes: { type: { DataType: 'String', StringValue: job.type, }, }, })); } // Publish to SNS async function publishEvent(topic: string, event: Event) { await sns.send(new PublishCommand({ TopicArn: `arn:aws:sns:${process.env.AWS_REGION}:${process.env.AWS_ACCOUNT}:${topic}`, Message: JSON.stringify(event), MessageAttributes: { eventType: { DataType: 'String', StringValue: event.type, }, }, })); } // Lambda SQS handler export const sqsHandler = async (event: SQSEvent) => { for (const record of event.Records) { const job = JSON.parse(record.body); await processJob(job); } }; ``` --- ## Google Cloud Platform ### Cloud Functions ```typescript import { HttpFunction, CloudEvent } from '@google-cloud/functions-framework'; // HTTP function export const httpHandler: HttpFunction = async (req, res) => { res.set('Access-Control-Allow-Origin', '*'); if (req.method === 'OPTIONS') { res.status(204).send(''); return; } try { const result = await processRequest(req.body); res.json(result); } catch (error) { console.error('Error:', error); res.status(500).json({ error: 'Internal error' }); } }; // Pub/Sub triggered function export const pubsubHandler = async (event: CloudEvent<{ message: { data: string } }>) => { const data = JSON.parse( Buffer.from(event.data.message.data, 'base64').toString() ); await processMessage(data); }; // Cloud Storage triggered export const storageHandler = async (event: CloudEvent<StorageObjectData>) => { const file = event.data; console.log(`Processing file: ${file.bucket}/${file.name}`); await processFile(file.bucket, file.name); }; ``` ### Firestore ```typescript import { Firestore, FieldValue } from '@google-cloud/firestore'; const db = new Firestore(); // Create document async function createUser(user: User) { const docRef = db.collection('users').doc(user.id); await docRef.set({ ...user, createdAt: FieldValue.serverTimestamp(), }); } // Query with filters async function getActiveUsers(limit = 10) { const snapshot = await db.collection('users') .where('status', '==', 'active') .orderBy('createdAt', 'desc') .limit(limit) .get(); return snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() })); } // Transaction async function transferCredits(fromId: string, toId: string, amount: number) { await db.runTransaction(async (t) => { const fromRef = db.collection('accounts').doc(fromId); const toRef = db.collection('accounts').doc(toId); const fromDoc = await t.get(fromRef); const fromBalance = fromDoc.data()?.balance || 0; if (fromBalance < amount) { throw new Error('Insufficient balance'); } t.update(fromRef, { balance: FieldValue.increment(-amount) }); t.update(toRef, { balance: FieldValue.increment(amount) }); }); } // Real-time listener function subscribeToUser(userId: string, callback: (user: User) => void) { return db.collection('users').doc(userId).onSnapshot((doc) => { if (doc.exists) { callback({ id: doc.id, ...doc.data() } as User); } }); } ``` --- ## Serverless Framework ### serverless.yml ```yaml service: my-api provider: name: aws runtime: nodejs18.x region: ${opt:region, 'us-east-1'} stage: ${opt:stage, 'dev'} environment: TABLE_NAME: ${self:service}-${self:provider.stage} BUCKET_NAME: ${self:service}-uploads-${self:provider.stage} iam: role: statements: - Effect: Allow Action: - dynamodb:Query - dynamodb:Scan - dynamodb:GetItem - dynamodb:PutItem - dynamodb:UpdateItem - dynamodb:DeleteItem Resource: - !GetAtt DynamoDBTable.Arn - !Join ['/', [!GetAtt DynamoDBTable.Arn, 'index/*']] - Effect: Allow Action: - s3:PutObject - s3:GetObject Resource: - !Join ['/', [!GetAtt S3Bucket.Arn, '*']] functions: api: handler: src/handlers/api.handler events: - http: path: /{proxy+} method: ANY cors: true processQueue: handler: src/handlers/queue.handler events: - sqs: arn: !GetAtt Queue.Arn batchSize: 10 scheduledTask: handler: src/handlers/scheduled.handler events: - schedule: rate(1 hour) resources: Resources: DynamoDBTable: Type: AWS::DynamoDB::Table Properties: TableName: ${self:provider.environment.TABLE_NAME} BillingMode: PAY_PER_REQUEST AttributeDefinitions: - AttributeName: PK AttributeType: S - AttributeName: SK AttributeType: S - AttributeName: GSI1PK AttributeType: S - AttributeName: GSI1SK AttributeType: S KeySchema: - AttributeName: PK KeyType: HASH - AttributeName: SK KeyType: RANGE GlobalSecondaryIndexes: - IndexName: GSI1 KeySchema: - AttributeName: GSI1PK KeyType: HASH - AttributeName: GSI1SK KeyType: RANGE Projection: ProjectionType: ALL S3Bucket: Type: AWS::S3::Bucket Properties: BucketName: ${self:provider.environment.BUCKET_NAME} Queue: Type: AWS::SQS::Queue Properties: QueueName: ${self:service}-${self:provider.stage}-queue plugins: - serverless-esbuild - serverless-offline ``` --- ## Cloudflare Workers ```typescript // worker.ts export interface Env { KV: KVNamespace; DB: D1Database;