AWS Serverless

1---
2name: aws-serverless
3description: "Specialized skill for building production-ready serverless applications on AWS. Covers Lambda functions, API Gateway, DynamoDB, SQS/SNS event-driven patterns, SAM/CDK deployment, and cold start optimization."
4source: vibeship-spawner-skills (Apache 2.0)
5---
6 
7# AWS Serverless
8 
9## Patterns
10 
11### Lambda Handler Pattern
12 
13Proper Lambda function structure with error handling
14 
15**When to use**: ['Any Lambda function implementation', 'API handlers, event processors, scheduled tasks']
16 
17```python
18```javascript
19// Node.js Lambda Handler
20// handler.js
21 
22// Initialize outside handler (reused across invocations)
23const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
24const { DynamoDBDocumentClient, GetCommand } = require('@aws-sdk/lib-dynamodb');
25 
26const client = new DynamoDBClient({});
27const docClient = DynamoDBDocumentClient.from(client);
28 
29// Handler function
30exports.handler = async (event, context) => {
31  // Optional: Don't wait for event loop to clear (Node.js)
32  context.callbackWaitsForEmptyEventLoop = false;
33 
34  try {
35    // Parse input based on event source
36    const body = typeof event.body === 'string'
37      ? JSON.parse(event.body)
38      : event.body;
39 
40    // Business logic
41    const result = await processRequest(body);
42 
43    // Return API Gateway compatible response
44    return {
45      statusCode: 200,
46      headers: {
47        'Content-Type': 'application/json',
48        'Access-Control-Allow-Origin': '*'
49      },
50      body: JSON.stringify(result)
51    };
52  } catch (error) {
53    console.error('Error:', JSON.stringify({
54      error: error.message,
55      stack: error.stack,
56      requestId: context.awsRequestId
57    }));
58 
59    return {
60      statusCode: error.statusCode || 500,
61      headers: { 'Content-Type': 'application/json' },
62      body: JSON.stringify({
63        error: error.message || 'Internal server error'
64      })
65    };
66  }
67};
68 
69async function processRequest(data) {
70  // Your business logic here
71  const result = await docClient.send(new GetCommand({
72    TableName: process.env.TABLE_NAME,
73    Key: { id: data.id }
74  }));
75  return result.Item;
76}
77```
78 
79```python
80# Python Lambda Handler
81# handler.py
82 
83import json
84import os
85import logging
86import boto3
87from botocore.exceptions import ClientError
88 
89# Initialize outside handler (reused across invocations)
90logger = logging.getLogger()
91logger.setLevel(logging.INFO)
92 
93dynamodb = boto3.resource('dynamodb')
94table = dynamodb.Table(os.environ['TABLE_NAME'])
95 
96def handler(event, context):
97    try:
98        # Parse i
99```
100 
101### API Gateway Integration Pattern
102 
103REST API and HTTP API integration with Lambda
104 
105**When to use**: ['Building REST APIs backed by Lambda', 'Need HTTP endpoints for functions']
106 
107```javascript
108```yaml
109# template.yaml (SAM)
110AWSTemplateFormatVersion: '2010-09-09'
111Transform: AWS::Serverless-2016-10-31
112 
113Globals:
114  Function:
115    Runtime: nodejs20.x
116    Timeout: 30
117    MemorySize: 256
118    Environment:
119      Variables:
120        TABLE_NAME: !Ref ItemsTable
121 
122Resources:
123  # HTTP API (recommended for simple use cases)
124  HttpApi:
125    Type: AWS::Serverless::HttpApi
126    Properties:
127      StageName: prod
128      CorsConfiguration:
129        AllowOrigins:
130          - "*"
131        AllowMethods:
132          - GET
133          - POST
134          - DELETE
135        AllowHeaders:
136          - "*"
137 
138  # Lambda Functions
139  GetItemFunction:
140    Type: AWS::Serverless::Function
141    Properties:
142      Handler: src/handlers/get.handler
143      Events:
144        GetItem:
145          Type: HttpApi
146          Properties:
147            ApiId: !Ref HttpApi
148            Path: /items/{id}
149            Method: GET
150      Policies:
151        - DynamoDBReadPolicy:
152            TableName: !Ref ItemsTable
153 
154  CreateItemFunction:
155    Type: AWS::Serverless::Function
156    Properties:
157      Handler: src/handlers/create.handler
158      Events:
159        CreateItem:
160          Type: HttpApi
161          Properties:
162            ApiId: !Ref HttpApi
163            Path: /items
164            Method: POST
165      Policies:
166        - DynamoDBCrudPolicy:
167            TableName: !Ref ItemsTable
168 
169  # DynamoDB Table
170  ItemsTable:
171    Type: AWS::DynamoDB::Table
172    Properties:
173      AttributeDefinitions:
174        - AttributeName: id
175          AttributeType: S
176      KeySchema:
177        - AttributeName: id
178          KeyType: HASH
179      BillingMode: PAY_PER_REQUEST
180 
181Outputs:
182  ApiUrl:
183    Value: !Sub "https://${HttpApi}.execute-api.${AWS::Region}.amazonaws.com/prod"
184```
185 
186```javascript
187// src/handlers/get.js
188const { getItem } = require('../lib/dynamodb');
189 
190exports.handler = async (event) => {
191  const id = event.pathParameters?.id;
192 
193  if (!id) {
194    return {
195      statusCode: 400,
196      body: JSON.stringify({ error: 'Missing id parameter' })
197    };
198  }
199 
200  const item =
201```
202 
203### Event-Driven SQS Pattern
204 
205Lambda triggered by SQS for reliable async processing
206 
207**When to use**: ['Decoupled, asynchronous processing', 'Need retry logic and DLQ', 'Processing messages in batches']
208 
209```python
210```yaml
211# template.yaml
212Resources:
213  ProcessorFunction:
214    Type: AWS::Serverless::Function
215    Properties:
216      Handler: src/handlers/processor.handler
217      Events:
218        SQSEvent:
219          Type: SQS
220          Properties:
221            Queue: !GetAtt ProcessingQueue.Arn
222            BatchSize: 10
223            FunctionResponseTypes:
224              - ReportBatchItemFailures  # Partial batch failure handling
225 
226  ProcessingQueue:
227    Type: AWS::SQS::Queue
228    Properties:
229      VisibilityTimeout: 180  # 6x Lambda timeout
230      RedrivePolicy:
231        deadLetterTargetArn: !GetAtt DeadLetterQueue.Arn
232        maxReceiveCount: 3
233 
234  DeadLetterQueue:
235    Type: AWS::SQS::Queue
236    Properties:
237      MessageRetentionPeriod: 1209600  # 14 days
238```
239 
240```javascript
241// src/handlers/processor.js
242exports.handler = async (event) => {
243  const batchItemFailures = [];
244 
245  for (const record of event.Records) {
246    try {
247      const body = JSON.parse(record.body);
248      await processMessage(body);
249    } catch (error) {
250      console.error(`Failed to process message ${record.messageId}:`, error);
251      // Report this item as failed (will be retried)
252      batchItemFailures.push({
253        itemIdentifier: record.messageId
254      });
255    }
256  }
257 
258  // Return failed items for retry
259  return { batchItemFailures };
260};
261 
262async function processMessage(message) {
263  // Your processing logic
264  console.log('Processing:', message);
265 
266  // Simulate work
267  await saveToDatabase(message);
268}
269```
270 
271```python
272# Python version
273import json
274import logging
275 
276logger = logging.getLogger()
277 
278def handler(event, context):
279    batch_item_failures = []
280 
281    for record in event['Records']:
282        try:
283            body = json.loads(record['body'])
284            process_message(body)
285        except Exception as e:
286            logger.error(f"Failed to process {record['messageId']}: {e}")
287            batch_item_failures.append({
288                'itemIdentifier': record['messageId']
289            })
290 
291    return {'batchItemFailures': batch_ite
292```
293 
294## Anti-Patterns
295 
296### ❌ Monolithic Lambda
297 
298**Why bad**: Large deployment packages cause slow cold starts.
299Hard to scale individual operations.
300Updates affect entire system.
301 
302### ❌ Large Dependencies
303 
304**Why bad**: Increases deployment package size.
305Slows down cold starts significantly.
306Most of SDK/library may be unused.
307 
308### ❌ Synchronous Calls in VPC
309 
310**Why bad**: VPC-attached Lambdas have ENI setup overhead.
311Blocking DNS lookups or connections worsen cold starts.
312 
313## ⚠️ Sharp Edges
314 
315| Issue | Severity | Solution |
316|-------|----------|----------|
317| Issue | high | ## Measure your INIT phase |
318| Issue | high | ## Set appropriate timeout |
319| Issue | high | ## Increase memory allocation |
320| Issue | medium | ## Verify VPC configuration |
321| Issue | medium | ## Tell Lambda not to wait for event loop |
322| Issue | medium | ## For large file uploads |
323| Issue | high | ## Use different buckets/prefixes |
324