giuseppe-trisciuoglio/developer-kit

aws-lambda-php-integration

Provides AWS Lambda integration patterns for PHP with Symfony using the Bref framework.

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill aws-lambda-php-integration

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

AWS Lambda PHP Integration

Patterns for deploying PHP and Symfony applications on AWS Lambda using the Bref framework.

Overview

Two approaches available:

  • Bref Framework - Standard PHP on Lambda with Symfony support, built-in routing, cold start < 2s
  • Raw PHP - Minimal overhead, maximum control, cold start < 500ms

Both support API Gateway integration with production-ready configurations.

When to Use

  • Creating new Lambda functions in PHP
  • Migrating existing Symfony applications to Lambda
  • Optimizing cold start performance
  • Configuring API Gateway or SQS/SNS event triggers
  • Setting up deployment pipelines for PHP Lambda

Instructions

1. Choose Your Approach

ApproachCold StartBest ForComplexity
Bref< 2sSymfony apps, full-featured APIsMedium
Raw PHP< 500msSimple handlers, maximum controlLow

2. Project Structure

Symfony with Bref Structure

my-symfony-lambda/
├── composer.json
├── serverless.yml
├── public/
│   └── index.php         # Lambda entry point
├── src/
│   └── Kernel.php        # Symfony Kernel
├── config/
│   ├── bundles.php
│   ├── routes.yaml
│   └── services.yaml
└── templates/

Raw PHP Structure

my-lambda-function/
├── public/
│   └── index.php         # Handler entry point
├── composer.json
├── serverless.yml
└── src/
    └── Services/

3. Implementation

Symfony with Bref:

php
// public/index.php
use Bref\Symfony\Bref;
use App\Kernel;
use Symfony\Component\HttpFoundation\Request;

require __DIR__.'/../vendor/autoload.php';

$kernel = new Kernel($_SERVER['APP_ENV'] ?? 'dev', $_SERVER['APP_DEBUG'] ?? true);
$kernel->boot();

$bref = new Bref($kernel);
return $bref->run($event, $context);

Raw PHP Handler:

php
// public/index.php
use function Bref\Lambda\main;

main(function ($event) {
    $path = $event['path'] ?? '/';
    $method = $event['httpMethod'] ?? 'GET';

    return [
        'statusCode' => 200,
        'body' => json_encode(['message' => 'Hello from PHP Lambda!'])
    ];
});

4. Cold Start Optimization

  1. Lazy loading - Defer heavy services until needed
  2. Disable unused Symfony features - Turn off validation, annotations
  3. Optimize composer autoload - Use classmap for production
  4. Use Bref optimized runtime - Leverage PHP 8.x optimizations

5. Connection Management

php
// Cache AWS clients at function level
use Aws\DynamoDb\DynamoDbClient;

class DatabaseService
{
    private static ?DynamoDbClient $client = null;

    public static function getClient(): DynamoDbClient
    {
        if (self::$client === null) {
            self::$client = new DynamoDbClient([
                'region' => getenv('AWS_REGION'),
                'version' => 'latest'
            ]);
        }
        return self::$client;
    }
}

Best Practices

Memory and Timeout

  • Memory: Start with 512MB for Symfony, 256MB for raw PHP
  • Timeout: Symfony 10-30s for cold start buffer, Raw PHP 3-10s typically sufficient

Dependencies

json
{
    "require": {
        "php": "^8.2",
        "bref/bref": "^2.0",
        "symfony/framework-bundle": "^6.0"
    },
    "config": {
        "optimize-autoloader": true,
        "preferred-install": "dist"
    }
}

Error Handling

php
try {
    $result = processRequest($event);
    return [
        'statusCode' => 200,
        'body' => json_encode($result)
    ];
} catch (ValidationException $e) {
    return [
        'statusCode' => 400,
        'body' => json_encode(['error' => $e->getMessage()])
    ];
} catch (Exception $e) {
    error_log($e->getMessage());
    return [
        'statusCode' => 500,
        'body' => json_encode(['error' => 'Internal error'])
    ];
}

Logging

php
error_log(json_encode([
    'level' => 'info',
    'message' => 'Request processed',
    'request_id' => $context->getAwsRequestId(),
    'path' => $event['path'] ?? '/'
]));

Deployment

Serverless Configuration

yaml
# serverless.yml
service: symfony-lambda-api

provider:
  name: aws
  runtime: php-82
  memorySize: 512
  timeout: 20

package:
  individually: true
  exclude:
    - '**/node_modules/**'
    - '**/.git/**'

functions:
  api:
    handler: public/index.php
    events:
      - http:
          path: /{proxy+}
          method: ANY

Deploy and Validate

bash
# 1. Install Bref
composer require bref/bref --dev

# 2. Test locally (validate before deploy)
sam local invoke -e event.json

# 3. Deploy
vendor/bin/bref deploy

# 4. Verify deployment
aws lambda invoke --function-name symfony-lambda-api-api \
  --payload '{"path": "/", "httpMethod": "GET"}' /dev/stdout

Symfony Full Configuration

yaml
# serverless.yml for Symfony
service: symfony-lambda-api

provider:
  name: aws
  runtime: php-82
  stage: ${self:custom.stage}
  region: ${self:custom.region}
  environment:
    APP_ENV: ${self:custom.stage}
    APP_DEBUG: ${self:custom.isLocal}
  iam:
    role:
      statements:
        - Effect: Allow
          Action:
            - dynamodb:GetItem
            - dynamodb:PutItem
          Resource: '*'

functions:
  web:
    handler: public/index.php
    timeout: 30
    memorySize: 1024
    events:
      - http:
          path: /{proxy+}
          method: ANY

  console:
    handler: bin/console
    timeout: 300
    events:
      - schedule: rate(1 day)

plugins:
  - ./vendor/bref/bref

custom:
  stage: dev
  region: us-east-1
  isLocal: false

Constraints and Warnings

Lambda Limits

  • Deployment package: 250MB unzipped maximum (50MB zipped)
  • Memory: 128MB to 10GB
  • Timeout: 29 seconds (API Gateway), 15 minutes for async
  • Concurrent executions: 1000 default

PHP-Specific Considerations

  • Cold start: PHP has moderate cold start; use Bref for optimized runtimes
  • Dependencies: Keep composer.json minimal; use Lambda Layers for shared deps
  • PHP version: Use PHP 8.2+ for best Lambda performance
  • No local storage: Lambda containers are ephemeral; use S3/DynamoDB for persistence

Common Pitfalls

  1. Large vendor folder - Exclude dev dependencies; use --no-dev
  2. Session storage - Don't use local file storage; use DynamoDB
  3. Long-running processes - Not suitable for Lambda; use ECS instead
  4. Websockets - Use API Gateway WebSockets or AppSync instead

Security Considerations

  • Never hardcode credentials; use IAM roles and SSM Parameter Store
  • Validate all input data
  • Use least privilege IAM policies
  • Enable CloudTrail for audit logging
  • Set proper CORS headers

Examples

Example 1: Create a Symfony Lambda API

Input: "Create a Symfony Lambda REST API using Bref for a todo application"

Process:

  1. Initialize Symfony project with composer create-project
  2. Install Bref: composer require bref/bref
  3. Configure serverless.yml
  4. Set up routes in config/routes.yaml
  5. Test locally: sam local invoke
  6. Deploy: vendor/bin/bref deploy
  7. Verify: aws lambda invoke --function-name <name> --payload '{}'

Output: Complete Symfony project structure with REST API, DynamoDB integration, deployment configuration

Example 2: Optimize Cold Start for Symfony

Input: "My Symfony Lambda has 5 second cold start, how do I optimize it?"

Process:

  1. Analyze services loaded at startup
  2. Disable unused Symfony features (validation, annotations)
  3. Use lazy loading for heavy services
  4. Optimize composer autoload
  5. Measure: Deploy and invoke to verify cold start < 2s

Output: Refactored Symfony configuration with cold start < 2s

Example 3: Deploy with GitHub Actions

Input: "Configure CI/CD for Symfony Lambda with Serverless Framework"

Process:

  1. Create GitHub Actions workflow
  2. Set up PHP environment with composer
  3. Run PHPUnit tests
  4. Deploy with Serverless Framework
  5. Validate: Check Lambda function exists and responds

Output: Complete .github/workflows/deploy.yml with multi-stage pipeline and test automation

References

  • [Bref Lambda](references/bref-lambda.md) - Complete Bref setup, Symfony integration, routing
  • [Raw PHP Lambda](references/raw-php-lambda.md) - Minimal handler patterns, caching, packaging
  • [Serverless Deployment](references/serverless-deployment.md) - Serverless Framework, SAM, CI/CD pipelines
  • [Testing Lambda](references/testing-lambda.md) - PHPUnit, SAM Local, integration testing

관련 작업

같은 저장소의 Skills

더 많은 Skills

모든 Skills
giuseppe-trisciuoglio
커뮤니티

drizzle-orm-patterns

Provides comprehensive Drizzle ORM patterns for schema definition, CRUD operations, relations, queries, transactions, and migrations. Proactively use for any Drizzle ORM development including defining database schemas, writing type-safe queries, implementing relations, managing transactions, and setting up migrations with Drizzle Kit. Supports PostgreSQL, MySQL, SQLite, MSSQL, and CockroachDB.

1시간 설치 수
3
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

tailwind-css-patterns

Provides comprehensive Tailwind CSS utility-first styling patterns including responsive design, layout utilities, flexbox, grid, spacing, typography, colors, and modern CSS best practices. Use when styling React/Vue/Svelte components, building responsive layouts, implementing design systems, or optimizing CSS workflow.

1시간 설치 수
1
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

dynamodb-toolbox-patterns

Provides TypeScript patterns for DynamoDB-Toolbox v2 including schema/table/entity modeling, .build() command workflow, query/scan access patterns, batch and transaction operations, and single-table design with computed keys. Use when implementing type-safe DynamoDB access layers with DynamoDB-Toolbox v2 in TypeScript services or serverless applications.

1시간 설치 수
1
GitHub Stars
371
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

spring-boot-dependency-injection

Provides dependency injection patterns for Spring Boot projects, including constructor-first design, optional collaborator handling, bean selection, and wiring validation. Use when creating services and configurations, replacing field injection, or troubleshooting ambiguous or fragile Spring wiring.

1시간 설치 수
1
GitHub Stars
371
업데이트
9월 10일