먼저 필요한 도구들을 설치해야 해. 터미널 열고 시작!

# Composer 설치 (이미 있으면 스킵)
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

# Serverless Framework 설치
npm install -g serverless

# AWS CLI 설치 (Mac 기준)
brew install awscli

# AWS 자격증명 설정
aws configure

AWS 자격증명 설정할 때는 IAM에서 적절한 권한을 가진 사용자를 만들어야 해. 최소한 Lambda, API Gateway, CloudFormation 권한은 필요하지! 🔑

# 라라벨 프로젝트 생성
composer create-project laravel/laravel web3-serverless
cd web3-serverless

# Bref 설치
composer require bref/bref bref/laravel-bridge

# Serverless 설정 파일 생성
php artisan vendor:publish --tag=serverless-config

이제 serverless.yml 파일을 설정해야 해. 이게 핵심이야!

service: web3-serverless-app

provider:
  name: aws
  region: ap-northeast-2  # 서울 리전
  runtime: provided.al2
  environment:
    APP_ENV: production
    APP_KEY: ${ssm:/web3-app/app-key}
    DB_CONNECTION: mysql
    DB_HOST: ${ssm:/web3-app/db-host}
    BLOCKCHAIN_RPC_URL: ${ssm:/web3-app/rpc-url}

functions:
  web:
    handler: public/index.php
    timeout: 28
    layers:
      - ${bref:layer.php-81-fpm}
    events:
      - httpApi: '*'
  
  artisan:
    handler: artisan
    timeout: 120
    layers:
      - ${bref:layer.php-81}
      - ${bref:layer.console}

plugins:
  - ./vendor/bref/bref

이제 블록체인과 통신할 준비를 해보자! PHP에서 Web3를 다루는 대표적인 라이브러리는 web3.php야.

# Web3.php 설치
composer require sc0vu/web3.php

# Ethereum 관련 추가 패키지
composer require kornrunner/keccak

간단한 Web3 서비스 클래스를 만들어보자:

<?php

namespace App\Services;

use Web3\Web3;
use Web3\Contract;
use Web3\Utils;

class Web3Service
{
    protected $web3;
    protected $eth;
    
    public function __construct()
    {
        $this->web3 = new Web3(env('BLOCKCHAIN_RPC_URL'));
        $this->eth = $this->web3->eth;
    }
    
    // 지갑 잔액 조회
    public function getBalance(string $address)
    {
        $balance = null;
        $this->eth->getBalance($address, function ($err, $result) use (&$balance) {
            if ($err !== null) {
                throw new \Exception($err->getMessage());
            }
            $balance = $result;
        });
        
        return Utils::fromWei($balance, 'ether');
    }
    
    // 스마트 컨트랙트 호출
    public function callContract(string $contractAddress, array $abi, string $method, array $params = [])
    {
        $contract = new Contract($this->web3->provider, $abi);
        $contract->at($contractAddress);
        
        $result = null;
        $contract->call($method, ...$params, function ($err, $res) use (&$result) {
            if ($err !== null) {
                throw new \Exception($err->getMessage());
            }
            $result = $res;
        });
        
        return $result;
    }
    
    // NFT 메타데이터 조회
    public function getNFTMetadata(string $contractAddress, int $tokenId)
    {
        $abi = json_decode(file_get_contents(storage_path('abi/erc721.json')), true);
        
        $tokenURI = $this->callContract($contractAddress, $abi, 'tokenURI', [$tokenId]);
        
        // IPFS URL 처리
        if (str_starts_with($tokenURI, 'ipfs://')) {
            $tokenURI = str_replace('ipfs://', 'https://ipfs.io/ipfs/', $tokenURI);
        }
        
        return json_decode(file_get_contents($tokenURI), true);
    }
}

이제 실제로 사용할 API를 만들어보자. 라라벨의 라우팅과 컨트롤러를 활용할 거야!

// routes/api.php
use App\Http\Controllers\Web3Controller;

Route::prefix('v1')->group(function () {
    // 지갑 정보 조회
    Route::get('/wallet/{address}', [Web3Controller::class, 'getWalletInfo']);
    
    // NFT 정보 조회
    Route::get('/nft/{contract}/{tokenId}', [Web3Controller::class, 'getNFT']);
    
    // 트랜잭션 전송
    Route::post('/transaction/send', [Web3Controller::class, 'sendTransaction']);
    
    // 스마트 컨트랙트 상호작용
    Route::post('/contract/interact', [Web3Controller::class, 'interactContract']);
});

컨트롤러 구현:

<?php

namespace App\Http\Controllers;

use App\Services\Web3Service;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Cache;

class Web3Controller extends Controller
{
    protected $web3Service;
    
    public function __construct(Web3Service $web3Service)
    {
        $this->web3Service = $web3Service;
    }
    
    public function getWalletInfo(string $address)
    {
        // 캐싱으로 성능 최적화 (Lambda는 콜드 스타트가 있으니까!)
        $cacheKey = "wallet:{$address}";
        
        return Cache::remember($cacheKey, 300, function () use ($address) {
            try {
                $balance = $this->web3Service->getBalance($address);
                
                return response()->json([
                    'success' => true,
                    'data' => [
                        'address' => $address,
                        'balance' => $balance,
                        'balance_usd' => $this->convertToUSD($balance),
                    ]
                ]);
            } catch (\Exception $e) {
                return response()->json([
                    'success' => false,
                    'error' => $e->getMessage()
                ], 500);
            }
        });
    }
    
    public function getNFT(string $contract, int $tokenId)
    {
        try {
            $metadata = $this->web3Service->getNFTMetadata($contract, $tokenId);
            
            return response()->json([
                'success' => true,
                'data' => [
                    'contract' => $contract,
                    'tokenId' => $tokenId,
                    'name' => $metadata['name'] ?? null,
                    'description' => $metadata['description'] ?? null,
                    'image' => $metadata['image'] ?? null,
                    'attributes' => $metadata['attributes'] ?? [],
                ]
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'error' => $e->getMessage()
            ], 500);
        }
    }
    
    private function convertToUSD(string $ethAmount): float
    {
        // 실제로는 외부 API에서 가격 가져와야 함
        $ethPrice = Cache::remember('eth_price', 60, function () {
            // CoinGecko API 등 활용
            return 2000; // 예시 가격
        });
        
        return floatval($ethAmount) * $ethPrice;
    }
}

Web3 앱이라도 사용자 정보나 트랜잭션 히스토리 같은 건 DB에 저장해야 할 때가 있지. Aurora Serverless를 사용하면 DB도 서버리스로 만들 수 있어! 💾

# serverless.yml에 추가
resources:
  Resources:
    AuroraCluster:
      Type: AWS::RDS::DBCluster
      Properties:
        Engine: aurora-mysql
        EngineMode: serverless
        DatabaseName: web3app
        MasterUsername: admin
        MasterUserPassword: ${ssm:/web3-app/db-password~true}
        ScalingConfiguration:
          MinCapacity: 2
          MaxCapacity: 16
          AutoPause: true
          SecondsUntilAutoPause: 300

라라벨 마이그레이션 예시:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateWeb3Tables extends Migration
{
    public function up()
    {
        // 사용자 지갑 테이블
        Schema::create('wallets', function (Blueprint $table) {
            $table->id();
            $table->string('address', 42)->unique();
            $table->string('chain')->default('ethereum');
            $table->timestamp('first_seen_at');
            $table->timestamp('last_activity_at')->nullable();
            $table->timestamps();
            
            $table->index(['chain', 'last_activity_at']);
        });
        
        // 트랜잭션 로그
        Schema::create('transaction_logs', function (Blueprint $table) {
            $table->id();
            $table->string('tx_hash', 66)->unique();
            $table->string('from_address', 42);
            $table->string('to_address', 42);
            $table->decimal('amount', 36, 18);
            $table->string('status')->default('pending');
            $table->text('error_message')->nullable();
            $table->timestamps();
            
            $table->index('status');
            $table->index('created_at');
        });
        
        // NFT 소유권 캐시
        Schema::create('nft_ownerships', function (Blueprint $table) {
            $table->id();
            $table->string('contract_address', 42);
            $table->unsignedBigInteger('token_id');
            $table->string('owner_address', 42);
            $table->json('metadata')->nullable();
            $table->timestamp('synced_at');
            $table->timestamps();
            
            $table->unique(['contract_address', 'token_id']);
            $table->index('owner_address');
        });
    }
    
    public function down()
    {
        Schema::dropIfExists('nft_ownerships');
        Schema::dropIfExists('transaction_logs');
        Schema::dropIfExists('wallets');
    }
}

블록체인 트랜잭션 모니터링이나 대량의 NFT 메타데이터 수집 같은 긴 작업은 비동기로 처리해야 해. SQS와 Lambda를 조합하면 완벽! 🎯

# serverless.yml에 추가
functions:
  # ... 기존 함수들
  
  worker:
    handler: worker.php
    timeout: 300
    layers:
      - ${bref:layer.php-81}
    events:
      - sqs:
          arn:
            Fn::GetAtt:
              - WorkerQueue
              - Arn
          batchSize: 1

resources:
  Resources:
    WorkerQueue:
      Type: AWS::SQS::Queue
      Properties:
        QueueName: web3-worker-queue
        VisibilityTimeout: 360

Job 클래스 만들기:

<?php

namespace App\Jobs;

use App\Services\Web3Service;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;

class SyncNFTMetadata implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable;
    
    protected $contractAddress;
    protected $tokenIds;
    
    public function __construct(string $contractAddress, array $tokenIds)
    {
        $this->contractAddress = $contractAddress;
        $this->tokenIds = $tokenIds;
    }
    
    public function handle(Web3Service $web3Service)
    {
        foreach ($this->tokenIds as $tokenId) {
            try {
                $metadata = $web3Service->getNFTMetadata($this->contractAddress, $tokenId);
                
                // DB에 저장
                \DB::table('nft_ownerships')->updateOrInsert(
                    [
                        'contract_address' => $this->contractAddress,
                        'token_id' => $tokenId,
                    ],
                    [
                        'metadata' => json_encode($metadata),
                        'synced_at' => now(),
                        'updated_at' => now(),
                    ]
                );
                
                // Rate limiting (블록체인 노드 보호)
                usleep(100000); // 0.1초 대기
                
            } catch (\Exception $e) {
                \Log::error("Failed to sync NFT: {$this->contractAddress}#{$tokenId}", [
                    'error' => $e->getMessage()
                ]);
            }
        }
    }
}

Job 디스패치:

// 컨트롤러에서
use App\Jobs\SyncNFTMetadata;

public function syncCollection(Request $request)
{
    $contractAddress = $request->input('contract_address');
    $totalSupply = $request->input('total_supply');
    
    // 100개씩 나눠서 처리
    $chunks = array_chunk(range(1, $totalSupply), 100);
    
    foreach ($chunks as $chunk) {
        SyncNFTMetadata::dispatch($contractAddress, $chunk);
    }
    
    return response()->json([
        'success' => true,
        'message' => 'Sync job queued',
        'jobs' => count($chunks)
    ]);
}

드디어 배포할 시간! 긴장되지? 😊

# 환경 변수 설정 (AWS Systems Manager Parameter Store)
aws ssm put-parameter \
  --name /web3-app/app-key \
  --value "base64:your-app-key-here" \
  --type SecureString

aws ssm put-parameter \
  --name /web3-app/rpc-url \
  --value "https://mainnet.infura.io/v3/YOUR-PROJECT-ID" \
  --type SecureString

# 배포!
serverless deploy

# 배포 완료되면 엔드포인트 URL이 나와
# 예: https://abc123.execute-api.ap-northeast-2.amazonaws.com

테스트해보자:

# 지갑 정보 조회
curl https://your-api-url.com/v1/wallet/0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb

# NFT 정보 조회
curl https://your-api-url.com/v1/nft/0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D/1

OpenSea 같은 NFT 마켓플레이스의 백엔드를 서버리스로 구축할 수 있어!

주요 기능:

• NFT 메타데이터 인덱싱 및 검색

• 실시간 가격 추적

• 거래 내역 조회

• 사용자 포트폴리오 관리

아키텍처:

API Gateway → Lambda (라라벨) → ElasticSearch (검색) + DynamoDB (메타데이터) + RDS (거래내역)

여러 DeFi 프로토콜의 데이터를 집계해서 보여주는 대시보드!

주요 기능:

• 멀티체인 지갑 잔액 조회

• 유동성 풀 APY 계산

• 포트폴리오 수익률 추적

• 가스비 최적화 추천

대규모 에어드랍을 효율적으로 처리!

워크플로우:

1. 사용자가 지갑 주소 등록

2. 자격 조건 검증 (Lambda)

3. 승인된 주소를 큐에 추가 (SQS)

4. 배치로 트랜잭션 전송 (Lambda Worker)

5. 결과 알림 (SNS)

스마트 컨트랙트 이벤트를 실시간으로 감지하고 처리!

<?php

namespace App\Services;

class EventListenerService
{
    public function listenToTransfers(string $contractAddress)
    {
        $web3 = new \Web3\Web3(env('BLOCKCHAIN_RPC_URL'));
        
        // Transfer 이벤트 필터
        $filter = [
            'fromBlock' => 'latest',
            'toBlock' => 'latest',
            'address' => $contractAddress,
            'topics' => [
                '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef' // Transfer 이벤트 시그니처
            ]
        ];
        
        $web3->eth->getLogs($filter, function ($err, $logs) {
            if ($err !== null) {
                \Log::error('Failed to get logs', ['error' => $err->getMessage()]);
                return;
            }
            
            foreach ($logs as $log) {
                $this->processTransferEvent($log);
            }
        });
    }
    
    private function processTransferEvent($log)
    {
        // 이벤트 데이터 파싱
        $from = '0x' . substr($log->topics[1], 26);
        $to = '0x' . substr($log->topics[2], 26);
        $tokenId = hexdec($log->data);
        
        // DB에 저장
        \DB::table('nft_transfers')->insert([
            'contract_address' => $log->address,
            'from_address' => $from,
            'to_address' => $to,
            'token_id' => $tokenId,
            'tx_hash' => $log->transactionHash,
            'block_number' => hexdec($log->blockNumber),
            'created_at' => now(),
        ]);
        
        // 알림 전송
        $this->notifyOwnerChange($log->address, $tokenId, $from, $to);
    }
}

EventBridge로 주기적 실행:

# serverless.yml
functions:
  eventListener:
    handler: listener.php
    events:
      - schedule: rate(1 minute)  # 1분마다 실행

• 요구사항 정의: 어떤 블록체인 기능이 필요한가?

• 트래픽 예상: 예상 사용자 수와 요청 패턴

• 비용 계산: AWS 계산기로 예상 비용 산출

• 보안 요구사항: 어떤 데이터를 다루는가?

• 핵심 기능만 먼저 구현

• 로컬에서 테스트

• 작은 규모로 Lambda에 배포

• 성능 측정 및 최적화

• CI/CD 파이프라인 구축 (GitHub Actions, GitLab CI)

• 모니터링 설정 (CloudWatch, X-Ray)

• 알람 설정 (SNS, Slack 연동)

• 백업 및 재해 복구 계획

• 로그 분석으로 병목 지점 파악

• 사용자 피드백 수집

• 지속적인 성능 개선

• 새로운 기능 추가