【メール配信編】プロフィールサイトAWS移行メモ 〜インフラ初心者を添えて〜

My_profile-cdk/
...
├── function/
│   ...
│   └── lambda/
│       └── send-mail.ts
├── lib/
│   └── constructs/
│   │   ...
│   │   └── mail-api-construct/
│   │       └── contact-api-construct.ts
│   │       └── mailer-function-construct.ts
│   │       └── ses-domain-construct.ts
│   └── stacks/
│   │   ...
│   │   └── mail-api-stack.ts
│   ...
├── parameters/
│   ...
│   └── mail-parameter.ts
...

...
 
export class CdnConstruct extends Construct {
  readonly distribution: cf.Distribution;
 
  constructor(scope: Construct, id: string, props: CdnConstructProps) {
    super(scope, id);
 
    ...
 
    // API Gateway へのオリジン（Contact用）
    const apiOrigin = new origins.HttpOrigin( 
      props.apiOriginForContact.domainName, 
      { 
        originPath: props.apiOriginForContact.originPath, 
        protocolPolicy: cf.OriginProtocolPolicy.HTTPS_ONLY, // API GW は HTTPS
      } 
    ); 
 
    // API の Preflight に必要なヘッダだけを転送するポリシー
    const apiCorsOriginRequestPolicy = new cf.OriginRequestPolicy( 
      this, 
      "ApiCorsReqPolicy", 
      { 
        comment: "Forward CORS preflight headers to API", 
        headerBehavior: cf.OriginRequestHeaderBehavior.allowList( 
          "Origin", 
          "Access-Control-Request-Method", 
          "Access-Control-Request-Headers"
        ), 
        queryStringBehavior: cf.OriginRequestQueryStringBehavior.all(), 
        cookieBehavior: cf.OriginRequestCookieBehavior.none(), 
      } 
    ); 
 
    // CloudFront Distribution
    this.distribution = new cf.Distribution(this, "Distribution", {
      defaultBehavior: {
        origin: origins.S3BucketOrigin.withOriginAccessControl(            // OACでS3を私的アクセス
          props.contentBucket
        ),
        viewerProtocolPolicy: cf.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,   // HTTP→HTTPS
        responseHeadersPolicy: headers,                                    // セキュリティヘッダ
        functionAssociations: rewriteFn                                    // ディレクトリ補完
          ? [
              {
                eventType: cf.FunctionEventType.VIEWER_REQUEST,
                function: rewriteFn,
              },
            ]
          : undefined,
        compress: true,                                                    // 自動圧縮
        cachePolicy: defaultCache,                                         // 上記キャッシュ方針
        allowedMethods: cf.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,          // 読み取り系のみ許可
      },
      additionalBehaviors: { 
        "api/*": { 
          origin: apiOrigin, 
          viewerProtocolPolicy: cf.ViewerProtocolPolicy.REDIRECT_TO_HTTPS, // HTTPS 強制
          allowedMethods: cf.AllowedMethods.ALLOW_ALL,                     // POST/OPTIONS 含む
          cachePolicy: cf.CachePolicy.CACHING_DISABLED,                    // フォームはキャッシュしない
          originRequestPolicy: apiCorsOriginRequestPolicy,                 // ヘッダ/クッキー/クエリを転送（安全策）
          responseHeadersPolicy: headers,                                  // 同じセキュリティヘッダ
          compress: false,                                                 // API は圧縮不要
        }, 
      }, 
      defaultRootObject: "index.html",                                     // ルート(/)はindex.html
      certificate: props.certificate,                                      // TLS終端
      domainNames: [props.domainName],                                     // ALTN(CNAME)
      errorResponses: [                                                    // 403/404は404.htmlへ
        {
          httpStatus: 404,
          responseHttpStatus: 404,
          responsePagePath: "/404.html",
          ttl: Duration.minutes(5),
        },
        {
          httpStatus: 403,
          responseHttpStatus: 404,
          responsePagePath: "/404.html",
          ttl: Duration.minutes(5),
        },
      ],
      priceClass: cf.PriceClass.PRICE_CLASS_200,                           // コスト/性能バランス
      minimumProtocolVersion: cf.SecurityPolicyProtocol.TLS_V1_2_2021,     // TLS最低バージョン
      httpVersion: cf.HttpVersion.HTTP3,                                   // HTTP/3対応
    });
 
    ...
  }
}

import { Construct } from "constructs";
import * as r53 from "aws-cdk-lib/aws-route53";
import * as ses from "aws-cdk-lib/aws-ses";
import { SesParams } from "@/parameters/mail-parameter";
import { HostedZoneRef } from "@/lib/stacks/dns-stack";
 
export interface SesDomainConstructProps extends SesParams {
  hostedZoneRef: HostedZoneRef;
}
 
export class SesDomainConstruct extends Construct {
  public readonly domainName: string;
 
  constructor(scope: Construct, id: string, props: SesDomainConstructProps) {
    super(scope, id);
 
    // Route53: 同一ゾーンを参照
    const zone = r53.HostedZone.fromHostedZoneAttributes(this, "ImportedZone", {
      hostedZoneId: props.hostedZoneRef.hostedZoneId,
      zoneName: props.hostedZoneRef.zoneName,
    });
 
    // SES ドメインアイデンティティを作成（DKIM & MAIL FROM 自動設定）
    new ses.EmailIdentity(this, "SesDomainIdentity", {
      identity: ses.Identity.publicHostedZone(zone),
      mailFromDomain: `${props.mailFromSubdomain}.${zone.zoneName}`,
    });
 
    // ゾーン名を公開
    this.domainName = zone.zoneName;
  }
}
 

import { Duration, RemovalPolicy } from "aws-cdk-lib";
import { Construct } from "constructs";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as lambdaNode from "aws-cdk-lib/aws-lambda-nodejs";
import * as logs from "aws-cdk-lib/aws-logs";
import * as iam from "aws-cdk-lib/aws-iam";
import { LambdaParams } from "@/parameters/mail-parameter";
 
export interface MailerFunctionConstructProps extends LambdaParams {
  domainName: string;
}
 
export interface MailerFunctionConstructOutputs {
  fn: lambdaNode.NodejsFunction;
}
 
export class MailerFunctionConstruct extends Construct {
  public readonly function: MailerFunctionConstructOutputs;
 
  constructor(
    scope: Construct,
    id: string,
    props: MailerFunctionConstructProps
  ) {
    super(scope, id);
 
    // 差出人メールアドレス
    const fromAddress = `${props.fromLocalPart}@${props.domainName}`;
 
    // 事前にロググループを作成
    const sendMailFnLogs = new logs.LogGroup(this, "SendMailFnLogs", {
      retention: logs.RetentionDays.ONE_MONTH, // ログ保持1ヶ月
      removalPolicy: RemovalPolicy.DESTROY,    // Destroy 方針
    });
 
    // 送信用のLambda関数を作成
    const fn = new lambdaNode.NodejsFunction(this, "SendMailFn", {
      entry: require.resolve("@/functions/lambda/send-mail.ts"), // Lambdaエントリ
      runtime: lambda.Runtime.NODEJS_20_X,                       // Node.js 20
      memorySize: 256,                                           // メモリ（256MB）
      timeout: Duration.seconds(10),                             // タイムアウト（10秒）
      bundling: { target: "node20" },                            // esbuildターゲット
      logGroup: sendMailFnLogs,
      environment: {
        FROM_EMAIL: fromAddress,                                 // 差出人
        TO_EMAIL  : props.fixedToGmail,                          // 宛先
        ALLOWED_ORIGINS: props.allowedOrigins.join(","),         // 許可するオリジン（カンマ区切り）
      }
    });
 
    // SES送信の最小権限（Fromを固定するConditionで縛る）
    fn.addToRolePolicy(
      new iam.PolicyStatement({
        actions: ["ses:SendEmail"],         // 送信に必要な権限
        resources: ["*"],                   // SESの仕様上"*"で可
        conditions: {
          StringEquals: {
            "ses:FromAddress": fromAddress, // 差出人を固定
          },
        },  
      })
    );
 
    this.function = { fn };
  }
}

$ npm i zod

import { Construct } from "constructs";
import * as logs from "aws-cdk-lib/aws-logs";
import * as apigw from "aws-cdk-lib/aws-apigateway";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as iam from "aws-cdk-lib/aws-iam";
import { Stack } from "aws-cdk-lib";
import { ApiGatewayParams } from "@/parameters/mail-parameter";
 
export interface ContactApiConstructProps extends ApiGatewayParams {
  handler: lambda.IFunction;
}
 
export interface ContactApiConstructOutputs {
  restApi: apigw.RestApi;
  apiDomainForCf: string;
  stageName: string;
}
 
export class ContactApiConstruct extends Construct {
  public readonly outputs: ContactApiConstructOutputs;
 
  constructor(scope: Construct, id: string, props: ContactApiConstructProps) {
    super(scope, id);
 
    const stageName = props.stageName ?? "prod";
 
    // アクセスログ用 LogGroup
    const accessLogs = new logs.LogGroup(this, "ApiAccessLogs", {
      retention: logs.RetentionDays.ONE_MONTH, // ログ保持期間は既定で 1ヶ月
    });
 
    // REST API（Regional）
    const api = new apigw.RestApi(this, "MailApi", {
      restApiName: "MailApi",
      description: "Contact form API (API Gateway → Lambda → SES)",
      endpointConfiguration: { types: [apigw.EndpointType.REGIONAL] },      // エンドポイント種別：Regional（CF から接続）
      deployOptions: {
        stageName,                                                          // ステージ名（"prod"）
        accessLogDestination: new apigw.LogGroupLogDestination(accessLogs), // アクセスログの出力先
        accessLogFormat: apigw.AccessLogFormat.jsonWithStandardFields({
          caller: true,                                                     // 呼び出し元（認証情報など）
          httpMethod: true,                                                 // HTTP メソッド（POST 等）
          ip: true,                                                         // クライアント IP
          protocol: true,                                                   // プロトコル（HTTP/1.1 等）
          requestTime: true,                                                // リクエスト時刻
          resourcePath: true,                                               // リソースパス（/contact）
          responseLength: true,                                             // レスポンスサイズ
          status: true,                                                     // ステータスコード
          user: true,                                                       // ユーザー識別（あれば）
        }),
        loggingLevel: apigw.MethodLoggingLevel.INFO,                        // メソッドログの詳細度（INFO：適度）
        metricsEnabled: true,                                               // CloudWatch メトリクス有効化（可観測性）
        dataTraceEnabled: false,                                            // リクエスト/レスポンス本文の生記録は無効（個人情報保護）
        throttlingBurstLimit: props.throttle.burst,                         // バースト制限（瞬間的な同時呼び出し数の上限）
        throttlingRateLimit: props.throttle.rate,                           // 1秒あたりの平均レート上限
      },
      ...(props.allowedOrigins && props.allowedOrigins.length > 0           // CORS を設定したいときだけオプションを付与
        ? {
            defaultCorsPreflightOptions: {                                  // 自動で OPTIONS 応答（プリフライト）を有効化
              allowOrigins: props.allowedOrigins,                           // 許可するオリジン
              allowMethods: ["POST", "OPTIONS"],                            // 使うメソッドだけ許可
              allowHeaders: ["Content-Type", "X-Requested-With"],           // 必要なヘッダだけ許可
            },
          }
        : {}),                                                              // CloudFront リバースプロキシのみで同一オリジンなら CORS 省略可
    });
 
    // (A) API Gateway → CloudWatch Logs 出力用の IAM ロール
    //     - 信頼ポリシー: apigateway.amazonaws.com
    //     - 付与権限   : AmazonAPIGatewayPushToCloudWatchLogs（AWS管理ポリシー）
    const apiGwCloudWatchRole =
      (this.node.tryFindChild("ApiGwCloudWatchRole") as iam.Role) ??
      new iam.Role(this, "ApiGwCloudWatchRole", {
        assumedBy: new iam.ServicePrincipal("apigateway.amazonaws.com"),
        managedPolicies: [
          iam.ManagedPolicy.fromAwsManagedPolicyName(
            "service-role/AmazonAPIGatewayPushToCloudWatchLogs"
          ),
        ],
      });
 
    // (B) アカウント設定（Region 単位で一意）にロール ARN を登録
    const apiGwAccount =
      (this.node.tryFindChild("ApiGwAccount") as apigw.CfnAccount) ??
      new apigw.CfnAccount(this, "ApiGwAccount", {
        cloudWatchRoleArn: apiGwCloudWatchRole.roleArn,
      });
 
    // (C) この設定が効いてから Stage を作るよう、Stage → Account に依存関係を張る
    const cfnStage = api.deploymentStage.node.defaultChild as apigw.CfnStage;
    cfnStage.addDependency(apiGwAccount);
 
    // 入力 JSON の簡易スキーマ（形式はLambda側で厳格確認）
    const requestModel = new apigw.Model(this, "ContactRequestModel", {
      restApi: api,
      contentType: "application/json",
      modelName: "ContactRequest",
      schema: {
        schema: apigw.JsonSchemaVersion.DRAFT4,                                          // スキーマバージョン
        title: "ContactRequest",                                                         // スキーマタイトル
        type: apigw.JsonSchemaType.OBJECT,                                               // オブジェクト形式の期待
        required: ["name", "email", "title", "message"],                                 // 必須4項目（フォーム仕様）
        properties: {
          name:    { type: apigw.JsonSchemaType.STRING, minLength: 1, maxLength: 100 },  // 名前：1〜100文字
          email:   { type: apigw.JsonSchemaType.STRING, minLength: 3, maxLength: 100 },  // メール：3〜100文字
          title:   { type: apigw.JsonSchemaType.STRING, minLength: 1, maxLength: 300 },  // タイトル：1〜300文字
          message: { type: apigw.JsonSchemaType.STRING, minLength: 1, maxLength: 5000 }, // 本文：1〜5000文字
        },
      },
    });
 
    // リクエストボディ検証器
    const bodyValidator = new apigw.RequestValidator(this, "BodyValidator", {
      restApi: api,
      validateRequestBody: true,                 // ボディのスキーマ検証をオン
      validateRequestParameters: false,          // クエリ/パスの検証は不要
      requestValidatorName: "BodyOnlyValidator",
    });
 
    // /contact（POST） → Lambda プロキシ統合
    const apiRoot = api.root.addResource("api");    // ルート直下に /api リソースを作成
    const contact = apiRoot.addResource("contact"); // /api/contact リソースを作成
    contact.addMethod(
      "POST",
      new apigw.LambdaIntegration(props.handler, { proxy: true }), // Lambda プロキシ統合（イベントそのまま渡す）
      {
        requestModels: { "application/json": requestModel },       // 上で定義したスキーマを適用
        requestValidator: bodyValidator,                           // 入力バリデーションを有効化
        apiKeyRequired: false,                                     // API キー不要（必要になれば後から有効化も可）
      }
    );
 
    // CloudFront のオリジンに使うドメイン名を生成
    const apiDomainForCf = `${api.restApiId}.execute-api.${Stack.of(this).region}.amazonaws.com`;
 
    this.outputs = { restApi: api, apiDomainForCf, stageName };
  }
}

$ npm i @aws-sdk/client-sesv2
$ npm i -D @types/aws-lambda
$ npm i -D esbuild

$ cdk synth

$ cdk diff MyProfileCdkStage/*

$ cdk deploy MyProfileCdkStage/DnsStack \
             MyProfileCdkStage/EdgeCertStack \
             MyProfileCdkStage/MailApiStack \
             MyProfileCdkStage/WebsiteStack \
             --concurrency 1

$ npm run build

$ aws s3 sync ./out s3://BUCKET_NAME --delete