AWS Mainframe Modernization 完全ガイド v2.0（2026年最新対応）

COBOL/JCL/VSAM メインフレームの AWS への段階的モダナイゼーション

AWS Mainframe Modernization（M2） は、「IBM z/OS・Micro Focus などのメインフレームワークロードを AWS マネージドサービスで実行・モダナイズするプラットフォーム」 である。COBOL / PL/I / VSAM / JCL ベースの銀行・保険・政府機関の基幹システムを、リホスト（Rehost / コード最小変更）またはリファクタリング（Refactor / Java 自動変換）で AWS に移行する。2026 年現在、管理ランタイム環境の新規顧客受け入れ終了が近づいているが、自管理体験は継続利用可能。

目次

1. ドキュメントメタデータ
2. 概要と課題
3. このサービスを選ぶ理由
4. アーキテクチャと設計原則
5. コアコンポーネント
6. 移行パターン詳細
7. 主要ユースケース
8. 設定・操作の具体例
9. 類似サービス比較表
10. ベストプラクティス
11. トラブルシューティング表
12. 2025-2026 最新動向
13. 学習リソース・参考文献
14. 実装例・チェックリスト
15. まとめ

ドキュメントメタデータ

• 最終更新: 2026-04-27
• バージョン: v2.0
• 対象者: Enterprise Architect、Mainframe SME、Migration Lead、DevOps Lead
• 難易度: 中級～上級
• 関連サービス: AWS Transform for Mainframe、EC2、ECS、RDS、Aurora、DMS、IAM Identity Center
• 廃止・変更予定: 管理ランタイム環境の新規顧客受け入れ終了予定。自管理体験は継続

概要と課題

本質

AWS Mainframe Modernization は 「COBOL・JCL・VSAM ベースのレガシーメインフレームアプリケーションを AWS で実行・近代化するマネージドプラットフォーム」 である。以下を実現する：

• 2 つの移行戦略：Rehost（コード最小化）と Refactor（Java 自動変換）を選択可能
• マネージドランタイム：Micro Focus / Rocket Software（旧 Micro Focus）ランタイムを AWS で提供
• VSAM → RDS 変換：メインフレームファイルシステム を 関係データベースに自動変換
• JCL → AWS Batch / Step Functions：バッチ処理を AWS ネイティブワークフローに変換
• 開発生産性向上：IDE・デバッグ・テストが IDE で完結

従来の課題

AWS Mainframe Modernization が提供する解決策

✅ メインフレーム互換ランタイム：COBOL・JCL・VSAM を AWS で実行（コード変更最小化）
✅ 2 つの移行パス：Rehost（短期）と Refactor（長期最適化）を並行・段階実施
✅ 完全管理ランタイム：インフラ管理・スケーリング・バックアップを AWS が担当
✅ データベース近代化：VSAM → RDS / Aurora への自動・段階的移行
✅ DevOps 統合：CloudFormation・IAM・CloudWatch で統一管理
✅ コスト削減：月額 ¥1,000 万メインフレーム → 月額 ¥200～400 万 AWS（70%～80% 削減）

このサービスを選ぶ理由

なぜ AWS Mainframe Modernization なのか？

1. メインフレームコスト構造の抜本的改革

   • 現在：z/OS ライセンス・HW・保守で月額 ¥1,500 万
   • AWS M2：EC2・RDS・ストレージで月額 ¥300 万（年間 ¥14.4 億削減）
   • ROI：初期投資 ¥10 億 → 18 ヶ月で回収

2. スケーラビリティの民主化

   • メインフレーム：容量拡張に数ヶ月・数億円
   • AWS：オートスケーリング、数分で処理能力向上（差分課金）

3. 段階的現代化が可能

   • 短期（Rehost）：コード変更最小化、クイック利益
   • 中期（Refactor）：段階的に Java マイクロサービス化
   • 長期（再構築）：クラウドネイティブアーキテクチャへ進化

4. 人的リソース問題の軽減

   • COBOL エキスパート不足 → Java 開発者の方が市場豊富
   • Refactor で Java 変換 → 若い世代エンジニアでメンテナンス可能

5. 組織変革の促進

   • メインフレーム = 中央集約 → クラウド = 分散・API 駆動
   • DevOps・マイクロサービス・CI/CD の導入が容易

このサービスを選ばない理由

• 小規模メインフレームワークロード：移行コスト > 保持コスト
• メインフレーム依存度低い（アプリ数 < 5）：個別リホストで十分
• 規制制約が特に厳しい（特定国内のみ稼働要件）：オンプレ継続

アーキテクチャと設計原則

全体構成図（Mermaid 1）

graph TB
    subgraph OnPrem["On-Premises Mainframe"]
        ZEOS["z/OS System<br/>(COBOL / JCL)<br/>(CICS / IMS)"]
        VSAM["VSAM File System<br/>(KSDS / ESDS)"]
        DB2["DB2 Database<br/>(Legacy relational)"]
    end
    
    subgraph M2["AWS Mainframe Modernization"]
        ENV["Environment<br/>(Managed Runtime)"]
        RUNTIME["Runtime Engine<br/>(Micro Focus / Rocket)"]
        STORAGE["File System<br/>(EFS / FSx)"]
    end
    
    subgraph ModernAWS["Modern AWS Infrastructure"]
        EC2["EC2 Instances<br/>(Rehost target)"]
        ECS["ECS / Fargate<br/>(Containerized)"]
        AURORA["Amazon Aurora<br/>(VSAM replacement)"]
        RDS["Amazon RDS<br/>(DB2 replacement)"]
    end
    
    subgraph DevOps["DevOps & Operations"]
        CF["CloudFormation<br/>(IaC)"]
        DMS["AWS DMS<br/>(Database migration)"]
        CW["CloudWatch<br/>(Monitoring)"]
        CODEPIPELINE["CodePipeline<br/>(CI/CD)"]
    end
    
    ZEOS --> RUNTIME
    VSAM --> STORAGE
    DB2 --> RDS
    
    RUNTIME --> ENV
    STORAGE --> ENV
    
    ENV --> EC2
    ENV --> ECS
    
    VSAM --> AURORA
    DB2 --> RDS
    
    CF --> ENV
    DMS --> RDS
    CW --> ENV
    CODEPIPELINE --> ENV

データフロー詳細

リホストパス（Rehost）:
  z/OS COBOL → Micro Focus ランタイム
  VSAM Files → AWS Batch / Lambda
  DB2 Tables → RDS Oracle compatible
  JCL Jobs → CloudFormation / Step Functions
  結果：6～12 ヶ月で稼働、最小コード変更

リファクタリングパス（Refactor）:
  COBOL ソース → AWS Transform for Mainframe
  ↓
  Java Spring Boot（自動生成）
  Angular フロントエンド（自動生成）
  Microservices アーキテクチャ（自動生成）
  結果：12～24 ヶ月でモダンアーキテクチャ、長期メンテナンス性向上

コアコンポーネント

1. Rehost Runtime（Micro Focus / Rocket Software）

役割：COBOL・JCL・VSAM をほぼ変更なしに AWS で実行

提供形式：

• Micro Focus ランタイム：z/OS 互換エミュレーション層
• Rocket Software ランタイム（旧 Micro Focus）：コンテナ化対応版
• マネージド環境（AWS 管理）または セルフマネージド環境（顧客管理）

実行モデル：

COBOL コード
  ↓ Micro Focus コンパイラで再コンパイル（変更最小化）
  ↓ AWS Mainframe Modernization Environment
  ↓ EC2 / ECS 上で実行
  ↓ VSAM / DB2 データアクセスは RDS / Aurora へ

メリット：

• COBOL ソース 85～95% はコード変更なし
• メインフレーム専門家の育成コスト削減
• 3～6 ヶ月でクイックな Go-Live 可能

2. Environment（マネージド実行環境）

役割：COBOL アプリケーション + ランタイム + インフラの統合管理

構成要素：

Application Environment
├── COBOL Runtime Engines（複数並行実行）
├── File System（VSAM レプリケーション・バックアップ）
├── Database Connectors（RDS・Aurora へのアクセス）
├── Transaction Manager（CICS トランザクション互換）
├── Batch Scheduler（JCL バッチ実行）
└── Monitoring & Logging（CloudWatch 統合）

スケーリング：

• 垂直スケーリング：インスタンスタイプアップグレード（自動・無停止可能）
• 水平スケーリング：複数インスタンスでの負荷分散（ALB）

3. Application Definition & Deployment

役割：COBOL アプリケーション + メタデータ + デプロイ設定を定義

形式：JSON 定義ファイル

{
  "definition": {
    "templateType": "COBOL_BINARY_APPLICATION",
    "sourceLocations": [
      {
        "source-id": "app-source",
        "source-type": "COBOL_OBJECT_FILES",
        "location": "s3://mainframe-apps/order-processing/bin/"
      }
    ],
    "dataStores": [
      {
        "name": "OrderDB",
        "type": "RDS_ORACLE",
        "endpoint": "order-db.xxxxx.rds.amazonaws.com:1521"
      }
    ],
    "startup": {
      "type": "JCL_JOB",
      "jobName": "ORDSTART",
      "stepName": "INITDB"
    }
  }
}

4. Data Stores（データストア変換）

VSAM → RDS / Aurora：

VSAM データ移行パターン：

Step 1: Unload VSAM data（メインフレーム）
        VSAM Records → CSV / Parquet
        ↓ S3 にアップロード
Step 2: AWS DMS で変換
        CSV → RDS schema（自動スキーママッピング）
Step 3: Delta レプリケーション
        オンプレ VSAM 更新 → RDS CDC（Change Data Capture）
Step 4: Application Refactor
        VSAM ファイルアクセス → RDS SQL クエリ

5. Batch Processing（バッチ処理現代化）

JCL → AWS Batch / Step Functions：

具体例：

メインフレーム JCL:
  //JOBJOB    JOB (ACCT),'ORDER PROCESSING'
  //STEP1     EXEC PGM=ORDREAD
  //INPUT     DD DSN=ORDER.VSAM.IN,DISP=SHR
  //OUTPUT    DD DSN=ORDER.PROCESSED,DISP=(NEW,CATLG)
  //STEP2     EXEC PGM=ORDWRITE,COND=(0,NE)
  
AWS Batch:
  AWS Batch Job Definition:
    - Container Image: COBOL Runtime + ORDREAD binary
    - Mount Points: S3 bucket（INPUT）
    - Output: S3 bucket（OUTPUT）
  
  Step Functions State Machine:
    States:
      - ReadOrdersJob: Batch job submit
      - WaitForCompletion: Check job status
      - ProcessOrdersJob: Second Batch job（条件付き実行）

移行パターン詳細

Rehost（リホスト・短期）

目標：COBOL コード最小化で AWS へ移行、メインフレームコスト削減

期間：6～12 ヶ月
コスト変更：最小
アーキテクチャ変更：最小

実装ステップ：

1. 準備フェーズ（Month 1-2）
   ├── COBOL ソースの棚卸し・依存関係マッピング
   ├── Micro Focus Analyzer で複雑度分析
   ├── AWS Mainframe Modernization Environment 環境構築
   └── テスト環境でコンパイル・実行確認
   
2. リホストフェーズ（Month 3-6）
   ├── COBOL オブジェクトファイルの再コンパイル
   ├── VSAM ファイル構造 → RDS スキーマへマッピング
   ├── JCL ジョブ → AWS Batch / Step Functions へ変換
   ├── CICS トランザクション → REST API へ適応
   └── Unit テスト・統合テスト
   
3. 検証フェーズ（Month 7-9）
   ├── User Acceptance Test（UAT）
   ├── データ検証（VSAM ↔ RDS レコード一致確認）
   ├── パフォーマンステスト（メインフレーム基準との比較）
   └── セキュリティ・監査
   
4. Go-Live フェーズ（Month 10-12）
   ├── Cutover ウィンドウ計画（最小化）
   ├── Parallel run（メインフレーム ↔ AWS 同時実行）
   ├── DNS / ロードバランサー切り替え
   └── メインフレーム本番停止・ライセンス終了

リホスト後の状態：

AWS で実行中：
  ├── COBOL アプリ（変更最小化）
  ├── VSAM Files → RDS Tables
  ├── Batch Jobs → AWS Batch Queues
  ├── CICS TXN → ALB + REST API
  └── IMS Database → RDS DBMS

メリット：
  ✅ メインフレーム ¥1,500万/月 → AWS ¥300万/月（80% 削減）
  ✅ 既知の COBOL コード保持（保守性向上）
  ✅ スケーラビリティ自動（EC2 オートスケーリング）
  ✅ DR 機能（AWS-native backup / failover）

Refactor（リファクタリング・長期）

目標：COBOL を Java に自動変換、マイクロサービス化、モダナイズ

期間：12～24 ヶ月
コスト変更：中程度
アーキテクチャ変更：大規模

実装ステップ：

1. 分析フェーズ（Month 1-3）
   ├── COBOL ソースコード深掘り分析（AWS Transform）
   ├── 複雑度・依存関係の全体図作成
   ├── マイクロサービス分解ポイント特定
   └── 変換リスク評価
   
2. 自動変換フェーズ（Month 4-9）
   ├── AWS Transform for Mainframe（Automated Refactor）
   ├── COBOL → Java Spring Boot（自動生成）
   ├── UI（CICS TXN） → Angular SPA（自動生成）
   ├── Data Layer → Hibernate ORM（自動生成）
   └── Unit Test 自動生成
   
3. 最適化フェーズ（Month 10-15）
   ├── 自動生成コードの手動最適化
   ├── Microservices 分割（DDD ドメイン単位）
   ├── API ゲートウェイ層の設計
   ├── Kubernetes / ECS デプロイ準備
   └── CI/CD パイプライン構築
   
4. テスト・検証フェーズ（Month 16-21）
   ├── Functional Test（メインフレーム基準との一致）
   ├── Non-Functional Test（パフォーマンス・スケーラビリティ）
   ├── Security Assessment（OWASP Top 10）
   └── User Acceptance Test（モダン UI の検証）
   
5. Go-Live フェーズ（Month 22-24）
   ├── Parallel run（レガシー ↔ モダン）
   ├── 段階的カットオーバー（機能単位）
   ├── 旧 COBOL コード段階的廃止
   └── 保守体制移行（新世代エンジニア）

リファクタ後の状態：

AWS で実行中：
  ├── Java Microservices（Spring Boot）
  ├── Angular SPA（モダン UI）
  ├── RDS / DynamoDB（データレイヤー）
  ├── EKS / ECS（コンテナ実行）
  ├── API Gateway（REST API）
  └── CloudWatch / X-Ray（可観測性）

メリット：
  ✅ 長期的なメンテナンス性向上
  ✅ クラウドネイティブ機能の活用
  ✅ スケーラビリティ・パフォーマンス最適化
  ✅ DevOps / CI/CD の完全実装
  ✅ マイクロサービス・API 駆動の組織変革

主要ユースケース

1. 銀行の勘定系システム移行（COBOL 100万行・VSAM 5TB）

シナリオ：大手銀行の顧客口座管理システム（50 年以上のレガシー）を AWS に移行

移行パターン：Rehost（短期） + Refactor（段階的）

Year 1: Rehost フェーズ
├── 環境構築：Mainframe Modernization Environment（m5.4xlarge × 2）
├── COBOL 再コンパイル：100 万行 → AWS ネイティブオブジェクト
├── VSAM 移行：5TB Account master → RDS Oracle（96h unload）
├── JCL バッチ：毎日 150 ジョブ → AWS Batch Queue へ
├── CICS トランザクション：REST API へ変換（ALB + ECS）
└── Go-Live：月末キャッシュフロー処理で初稼働

Year 1 コスト：
  ├── メインフレーム→AWS: ¥1,500万→300万/月（80%削減）
  ├── 初期投資（移行・テスト）：¥8億
  └── ROI：12ヶ月で回収

Year 2-3: Refactor フェーズ
├── COBOL → Java Spring Boot（モジュール単位）
  └── 顧客照会 → CustomerService Microservice
  └── 入出金 → TransactionService Microservice
├── Angular モダン UI（既存テラミナル → Web）
├── API Gateway（内部・提携銀行連携）
└── EKS での Kubernetes 運用

Year 3 最終状態：
  ✅ 完全なモダンアーキテクチャ
  ✅ マイクロサービス・API駆動
  ✅ スケーラビリティ 10x 向上
  ✅ 人的リソース効率 2x 向上

2. 保険会社の査定システム（IMS DB + COBOL）

シナリオ：自動車保険・損害査定システム（リアルタイム処理）

課題：IMS Database → RDS への変換

メインフレーム IMS:
  └── Hierarchical DB
      ├── Policy Tree（保険契約）
      ├── Claim Tree（請求記録）
      └── History Tree（変更履歴）

AWS 設計:
  └── RDS Oracle（関係スキーマ）
      ├── Policy Table（PK: policy_id）
      ├── Claim Table（PK: claim_id, FK: policy_id）
      └── ClaimHistory Table（PK: history_id, FK: claim_id）

変換処理:
  1. IMS DBUnload → CSV（AWS DMS）
  2. スキーママッピング（HierarchicalJSON → Relational）
  3. CDC レプリケーション（オンプレIMS → RDS）
  4. アプリケーション適応：
     IMS DL/I コール → SQL クエリ

3. 政府機関の給与・福利厚生システム

シナリオ：公務員給与計算（数百万件・毎月定期実行）

利点：AWS のセキュリティ・監査・コンプライアンス機能

メインフレーム:
  ├── Batch Processing（毎月 1 日：給与計算）
  ├── VSAM Employee Master（数百万件）
  ├── JCL Job Control（複雑な依存関係）
  └── Tape バックアップ（月ごと）

AWS で実装:
  ├── AWS Batch Job Queue（毎月 1 日自動トリガー）
  ├── RDS Aurora（Employee Master）
  ├── Step Functions（Job Dependencies 管理）
  ├── CloudWatch Logs（完全な監査ログ）
  ├── KMS Encryption（給与データ暗号化）
  └── AWS Backup（自動世代管理）

セキュリティ強化:
  ✅ HIPAA / FedRAMP コンプライアンス
  ✅ Encryption at rest / in transit
  ✅ VPC 隔離
  ✅ CloudTrail 全操作監査

設定・操作の具体例

CLI ベースの操作

1. Environment 作成（Micro Focus）

aws m2 create-environment \
  --name "prod-mainframe-env-01" \
  --engine-type microfocus \
  --engine-version "8.0" \
  --instance-type m5.4xlarge \
  --high-availability-config desiredCapacity=2 \
  --subnet-ids subnet-12345abc subnet-67890def \
  --security-group-ids sg-mainframe \
  --storage-configurations '[{
    "efs": {
      "fileSystemId": "fs-abcd1234",
      "mountPoint": "/opt/mainframe/data"
    }
  }]' \
  --region ap-northeast-1

# 出力例：
# {
#   "environmentId": "env-abc123def456"
# }

2. Application 定義・デプロイ

# アプリケーション定義ファイル作成
cat > application-def.json << 'EOF'
{
  "definition": {
    "templateType": "COBOL_BINARY_APPLICATION",
    "sourceLocations": [
      {
        "source-id": "order-app",
        "source-type": "COBOL_OBJECT_FILES",
        "location": "s3://mainframe-apps/order-processing/bin/"
      }
    ],
    "dataStores": [
      {
        "name": "OrderDB",
        "type": "RDS_ORACLE",
        "endpoint": "order-db.xxxxx.rds.amazonaws.com:1521"
      },
      {
        "name": "OrderCache",
        "type": "RDS_MYSQL",
        "endpoint": "order-cache.xxxxx.rds.amazonaws.com:3306"
      }
    ],
    "startup": {
      "type": "JCL_JOB",
      "jobName": "ORDERSTARTUP",
      "stepName": "INITDB"
    }
  }
}
EOF

# アプリケーション作成
aws m2 create-application \
  --name "order-processing-app" \
  --engine-type microfocus \
  --definition file://application-def.json \
  --region ap-northeast-1

# 出力例：
# {
#   "applicationId": "app-xyz789abc"
# }

3. Application デプロイ

aws m2 create-deployment \
  --application-id app-xyz789abc \
  --application-version 1 \
  --environment-id env-abc123def456 \
  --region ap-northeast-1

# デプロイ進捗確認
aws m2 describe-deployment \
  --deployment-id deploy-123 \
  --region ap-northeast-1 \
  --query 'deployment.[status, statusReason]'

4. Batch Job スケジュール

# AWS Batch Job Definition（COBOL Batch）
aws batch register-job-definition \
  --job-definition-name "cobol-order-processing" \
  --type container \
  --container-properties '{
    "image": "123456789012.dkr.ecr.ap-northeast-1.amazonaws.com/mainframe-runtime:latest",
    "vcpus": 4,
    "memory": 8192,
    "jobRoleArn": "arn:aws:iam::123456789012:role/BatchJobRole",
    "environment": [
      {
        "name": "COBOL_PROGRAM",
        "value": "ORDPROCESS"
      },
      {
        "name": "VSAM_DATASET",
        "value": "rds://order-db/orders_table"
      }
    ],
    "mountPoints": [
      {
        "sourceVolume": "mainframe-storage",
        "containerPath": "/data",
        "readOnly": false
      }
    ]
  }' \
  --region ap-northeast-1

# Job Queue 作成
aws batch create-job-queue \
  --job-queue-name "mainframe-batch-queue" \
  --state ENABLED \
  --priority 100 \
  --compute-environment-order computeEnvironment=compute-env-01,order=1 \
  --region ap-northeast-1

# Job サブミット（毎月 1 日午前 2 時）
aws batch submit-job \
  --job-name "monthly-payroll-calc" \
  --job-queue "mainframe-batch-queue" \
  --job-definition "cobol-order-processing" \
  --region ap-northeast-1

SDK ベースの操作（Python）

import boto3
from datetime import datetime

m2_client = boto3.client('m2', region_name='ap-northeast-1')

# Step 1: Environment 一覧
def list_environments():
    response = m2_client.list_environments()
    for env in response['environments']:
        print(f"ID: {env['environmentId']}, Status: {env['status']}")
    return response['environments']

# Step 2: Application デプロイ
def deploy_application(app_id, env_id, version=1):
    response = m2_client.create_deployment(
        applicationId=app_id,
        applicationVersion=version,
        environmentId=env_id
    )
    deployment_id = response['deploymentId']
    print(f"Deployment started: {deployment_id}")
    return deployment_id

# Step 3: デプロイ進捗監視
def wait_for_deployment(deployment_id):
    waiter = m2_client.get_waiter('deployment_complete')
    try:
        waiter.wait(deploymentId=deployment_id)
        print("Deployment completed successfully")
    except Exception as e:
        print(f"Deployment failed: {e}")

# Step 4: Application 起動
def start_application(app_id):
    response = m2_client.start_application(
        applicationId=app_id
    )
    print(f"Application started: {response['applicationId']}")

# 実行例
if __name__ == "__main__":
    # Environment 確認
    envs = list_environments()
    env_id = envs[0]['environmentId'] if envs else None
    
    if env_id:
        # Application デプロイ
        deploy_id = deploy_application('app-xyz', env_id)
        
        # 完了待機
        wait_for_deployment(deploy_id)
        
        # Application 起動
        start_application('app-xyz')

IaC ベースの操作（CloudFormation）

AWSTemplateFormatVersion: '2010-09-09'
Description: 'AWS Mainframe Modernization Complete Stack'

Parameters:
  EnvironmentName:
    Type: String
    Default: production
  EngineType:
    Type: String
    AllowedValues: [microfocus, bluage]
    Default: microfocus

Resources:
  # VPC and Networking
  MainframeVPC:
    Type: AWS::EC2::VPC
    Properties:
      CidrBlock: 10.0.0.0/16
      EnableDnsHostnames: true
      Tags:
        - Key: Name
          Value: !Sub '${EnvironmentName}-vpc'

  MainframeSubnet:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId: !Ref MainframeVPC
      CidrBlock: 10.0.1.0/24
      AvailabilityZone: !Select [0, !GetAZs '']

  # Security Group
  MainframeSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Security group for Mainframe Environment
      VpcId: !Ref MainframeVPC
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 443
          ToPort: 443
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 3306
          ToPort: 3306
          CidrIp: 10.0.0.0/16

  # RDS Database for VSAM replacement
  OrderDatabase:
    Type: AWS::RDS::DBCluster
    Properties:
      Engine: aurora-mysql
      MasterUsername: admin
      MasterUserPassword: !Sub '{{resolve:secretsmanager:${DBSecret}:SecretString:password}}'
      DatabaseName: orders
      DBSubnetGroupName: !Ref DBSubnetGroup
      VpcSecurityGroupIds:
        - !Ref MainframeSecurityGroup
      BackupRetentionPeriod: 30
      PreferredBackupWindow: '02:00-03:00'
      Tags:
        - Key: Name
          Value: !Sub '${EnvironmentName}-order-db'

  DBSubnetGroup:
    Type: AWS::RDS::DBSubnetGroup
    Properties:
      DBSubnetGroupDescription: Subnet group for Mainframe DB
      SubnetIds:
        - !Ref MainframeSubnet

  # EFS for file storage
  MainframeFileSystem:
    Type: AWS::EFS::FileSystem
    Properties:
      PerformanceMode: generalPurpose
      ThroughputMode: bursting
      Tags:
        - Key: Name
          Value: !Sub '${EnvironmentName}-fs'

  # CloudWatch Log Group
  MainframeLogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub '/aws/mainframe/${EnvironmentName}'
      RetentionInDays: 30

  # IAM Role for Application
  MainframeApplicationRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub '${EnvironmentName}-app-role'
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: ec2.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: MainframeAccess
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - rds:DescribeDBClusters
                  - rds:DescribeDBInstances
                  - elasticfilesystem:DescribeFileSystems
                  - logs:PutLogEvents
                  - kms:Decrypt
                Resource: '*'

Outputs:
  DatabaseEndpoint:
    Value: !GetAtt OrderDatabase.Endpoint.Address
    Description: RDS Cluster Endpoint
  
  FileSystemId:
    Value: !Ref MainframeFileSystem
    Description: EFS File System ID
  
  LogGroupName:
    Value: !Ref MainframeLogGroup
    Description: CloudWatch Log Group

類似サービス比較表

ベストプラクティス

1. 移行パターン選定

✅ 推奨：

• Rehost（短期メリット重視）：メインフレーム年間 ¥1,000万以上のコスト圧力
• Refactor（長期最適化重視）：エンジニア採用困難・モダナイズ必要性
• ハイブリッド：最初 Rehost → 2～3年後に段階的 Refactor

❌ アンチパターン：

• リホストなし、いきなり Refactor（24～36 ヶ月待機、コスト削減遅延）
• 無制限のリファクタ（パフェクション主義、Go-Live 遅延）

2. Data Migration 戦略

✅ 推奨：

• 段階的移行：VSAM → RDS（最初は少数テーブル）
• Dual write：オンプレ VSAM ・AWS RDS 両方に書き込み（逆方向 CDC）
• 検証期間：最小 2～4 週間のパラレル実行（データ一致確認）

❌ アンチパターン：

• 一括 Unload / Reload（リスク集中）
• データ検証なし（バグ発見後の修正が困難）

3. Performance & Scaling

✅ 推奨：

• Initial Size：m5.2xlarge × 2（HA）～ m5.4xlarge × 2（Large App）
• Monitor：CloudWatch + CloudTrail（COBOL パフォーマンス追跡）
• Right-size：3～6 ヶ月後に使用率分析、ダウンサイジング検討

❌ アンチパターン：

• 初期から大規模インスタンス（未使用 vCPU は無駄）
• パフォーマンス監視なし（スケーリング判定困難）

4. DevOps & CI/CD

✅ 推奨：

• IaC すべてに：Environment / Application / Database を CloudFormation で定義
• CI/CD パイプライン：CodePipeline で COBOL ビルド・デプロイ自動化
• Testing Automation：Unit Test + Integration Test（COBOL も Java も）

❌ アンチパターン：

• 手動デプロイ（エラー・属人化）
• テスト不足（本番バグ多発）

トラブルシューティング表

2025-2026 最新動向

1. AWS Transform for Mainframe の拡張

詳細：

• Automated Refactor エンジン の精度向上（COBOL 複雑度 95%+ 対応）
• UI 自動変換（CICS Terminal → Angular SPA）の完全自動化
• AI による “Dead Code” 自動削除提案

2. マネージドランタイム環境の形態変化

2026 年予定：

• 従来の “Managed Runtime Environment” → Self-Managed Experience へシフト
• 顧客が EC2 / ECS で COBOL ランタイムを自管理（AWS サポート継続）
• コスト削減・柔軟性向上

3. Modernization Hub ツール統合

計画中：

• AWS Transform for Mainframe ↔ AWS Mainframe Modernization の統合強化
• 単一ダッシュボードで進捗管理（Rehost ・ Refactor 並行実施）

4. Database Modernization の自動化

2026 年強化予定：

• DMS Fleet Advisor との統合深化
• VSAM ・ IMS → RDS / Aurora の自動スキーママッピング
• Data Migration Validation ツール自動化

学習リソース・参考文献

公式ドキュメント

コミュニティ・パートナー

実装例・チェックリスト

実装例：銀行勘定系システム移行スクリプト

#!/bin/bash
# AWS Mainframe Modernization - Full Migration Script

set -e

ACCOUNT_ID="123456789012"
REGION="ap-northeast-1"
APP_NAME="bank-accounting-system"

echo "=== AWS Mainframe Modernization セットアップ ==="

# Step 1: VPC・Network セットアップ
echo "[1/6] VPC・Network 構築..."
aws cloudformation create-stack \
  --stack-name ${APP_NAME}-network \
  --template-body file://network-stack.yaml \
  --region ${REGION}

aws cloudformation wait stack-create-complete \
  --stack-name ${APP_NAME}-network \
  --region ${REGION}

# Step 2: RDS Database 作成
echo "[2/6] RDS Database 作成..."
aws rds create-db-cluster \
  --db-cluster-identifier ${APP_NAME}-db \
  --engine aurora-mysql \
  --master-username admin \
  --master-user-password $(openssl rand -base64 32) \
  --database-name accounting_db \
  --region ${REGION}

# Step 3: EFS ファイルシステム作成
echo "[3/6] EFS ファイルシステム作成..."
EFS_ID=$(aws efs create-file-system \
  --performance-mode generalPurpose \
  --throughput-mode bursting \
  --region ${REGION} \
  --query 'FileSystemId' --output text)
echo "EFS ID: ${EFS_ID}"

# Step 4: IAM ロール作成
echo "[4/6] IAM ロール作成..."
aws iam create-role \
  --role-name ${APP_NAME}-m2-role \
  --assume-role-policy-document file://assume-role-policy.json

aws iam attach-role-policy \
  --role-name ${APP_NAME}-m2-role \
  --policy-arn arn:aws:iam::aws:policy/AWSMainframeModernizationFullAccess

# Step 5: M2 Environment 作成
echo "[5/6] M2 Environment 作成..."
ENV_ID=$(aws m2 create-environment \
  --name "${APP_NAME}-env" \
  --engine-type microfocus \
  --engine-version "8.0" \
  --instance-type m5.4xlarge \
  --high-availability-config desiredCapacity=2 \
  --region ${REGION} \
  --query 'environmentId' --output text)
echo "Environment ID: ${ENV_ID}"

# Step 6: Application デプロイ
echo "[6/6] Application デプロイ..."
APP_ID=$(aws m2 create-application \
  --name ${APP_NAME} \
  --engine-type microfocus \
  --definition file://app-definition.json \
  --region ${REGION} \
  --query 'applicationId' --output text)
echo "Application ID: ${APP_ID}"

# デプロイ実行
DEPLOY_ID=$(aws m2 create-deployment \
  --application-id ${APP_ID} \
  --application-version 1 \
  --environment-id ${ENV_ID} \
  --region ${REGION} \
  --query 'deploymentId' --output text)
echo "Deployment ID: ${DEPLOY_ID}"

# 完了待機
aws m2 wait deployment-complete --deployment-id ${DEPLOY_ID} --region ${REGION}

echo ""
echo "=== セットアップ完了 ==="
echo "Environment ID: ${ENV_ID}"
echo "Application ID: ${APP_ID}"
echo "Database: ${APP_NAME}-db (Aurora MySQL)"
echo "File System: ${EFS_ID} (EFS)"

移行チェックリスト

• [ ] 事前準備

  • [ ] スコープ・予算・スケジュール承認
  • [ ] リホスト vs リファクタ判定
  • [ ] AWS Account・IAM 準備

• [ ] 環境構築

  • [ ] VPC・Subnet・Security Group
  • [ ] RDS Database（VSAM 置き換え）
  • [ ] EFS（ファイルストレージ）
  • [ ] M2 Environment 作成

• [ ] Application 準備

  • [ ] COBOL ソース・オブジェクト収集
  • [ ] 依存関係分析
  • [ ] Application Definition ファイル作成

• [ ] Data Migration

  • [ ] VSAM Unload スクリプト作成
  • [ ] DMS Task 設定（VSAM → RDS）
  • [ ] データ検証スクリプト

• [ ] テスト・検証

  • [ ] Unit Test（COBOL も Java も）
  • [ ] Integration Test（DB連携）
  • [ ] Performance Test
  • [ ] UAT

• [ ] 本番移行

  • [ ] Cutover Window 計画
  • [ ] Parallel Run（オンプレ ↔ AWS）
  • [ ] DNS 切り替え
  • [ ] メインフレーム停止・ライセンス終了

まとめ

AWS Mainframe Modernization は 「COBOL・JCL・VSAM メインフレームアプリケーションを AWS で実行・モダナイズする完全なマネージドプラットフォーム」 である。

主な価値

1. メインフレームコスト 70～80% 削減：年間 ¥15 億 → ¥3～4 億
2. 柔軟な移行戦略：Rehost（短期）+ Refactor（長期）の段階的実施
3. インフラ管理の自動化：AWS マネージド ランタイムでメンテナンス負荷削減
4. スケーラビリティ：メインフレーム容量拡張（数ヶ月・数億円）→ AWS オートスケーリング（数分）
5. 人的資産の保護：COBOL → Java 自動変換で若い世代エンジニアでのメンテナンス可能

注意点

• 管理ランタイム新規受け入れ終了予定：自管理体験への移行を検討
• 最低 6～12 ヶ月の移行期間：並行テスト・検証は必須
• 専門知識が必要：AWS Mainframe Competency Partner との協業推奨

適用判定

✅ 使うべき：

• メインフレーム年間コスト > ¥1,000万
• COBOL エキスパート確保困難
• スケーラビリティ・災害対策の強化必要

❌ 不要：

• 小規模レガシー（5 アプリ未満）
• 既に他クラウドで実行

最終更新：2026-04-27
バージョン：v2.0