人工智能

使用 Amazon Bedrock 和 AWS Transform 将大型机 Assembler 现代化为 Java

设想有一个批处理作业,几十年来每晚运行从未失败,而唯一能看懂其代码的人即将退休。在与银行、保险和航空公司客户合作时,我们一次又一次地看到这种情况。他们的 Assembler 程序仍在运行关键业务操作,但每年能读懂这些程序的人越来越少。手工重写这些程序需要数年时间,存在破坏无人记得曾编写过的业务规则的风险,而且仍然依赖于那些正在离开的同一批专家。 Amazon Bedrock 和 AWS Transform 改变了这一局面。

本文介绍一种多阶段转换方法,使用 Amazon Bedrock, Kiro IDE (一个由 AI 驱动的集成开发环境)和 AWS Transform ,与手动方法相比,该方法有助于缩短现代化时间,同时通过验证检查点保持业务逻辑的完整性。您将学习如何系统地从 Assembler 代码中提取业务规则,通过中间 COBOL 阶段进行转换,并将现代化后的应用程序作为 Java Spring Boot 服务部署到 AWS 上。

先决条件

在开始现代化流程之前,请确保您具备:

  • 有效的 AWS 账户 ,并具有针对 Amazon Bedrock、AWS Transform 和 Amazon Simple Storage Service(Amazon S3)的最小权限 AWS Identity and Access Management(IAM)权限。
  • 对 Amazon Q Developer 或 Kiro 的访问权限,用于 AI 辅助代码分析。
  • 对 AWS Transform 的访问权限,用于 COBOL 到 Java 的转换。
  • 对 Amazon Bedrock 的访问权限,并可使用适当的基础模型(FM)。
  • 一个已配置用于源代码和构件存储的 Amazon S3 存储桶,并启用了加密和阻止公共访问。
  • 对目标业务领域和应用程序功能的了解。
  • 业务和技术主题专家(SME)可参与验证会议。
  • 源 Assembler 代码清单及可用的文档。
  • 用于功能等价测试的测试数据集及预期输出。

解决方案概述

您可以通过系统化的五阶段方法,将紧密绑定 COBOL 的遗留大型机 Assembler 应用程序转换为为 AWS 云构建的 Java Spring Boot 应用程序。这种多阶段方法先将 Assembler 转换为 COBOL 作为中间步骤,然后再进行 Java 转换,与直接从 Assembler 转换为 Java 相比,可降低风险并更可靠地保留业务逻辑。中间 COBOL 阶段提供了一种结构化、人类可读的格式,主题专家(SME)可以在最终转换之前对其进行验证。这确保业务规则在整个现代化过程中保持完整。以下各节描述了当前大型机架构和以云为目标的目标状态。

当前状态

您当前的架构代表传统的大型机环境,其中 Assembler 程序执行批处理流程,与 COBOL 相连,与数据库交互并处理文件。其核心是,JCL(作业控制语言)作业按计划间隔触发 Assembler 程序执行。这些程序从 VSAM(虚拟存储访问方法)和顺序文件中读取输入,并对 IBM Db2 for z/OS 执行操作。您的业务逻辑使用低级寄存器操作(直接 CPU 寄存器操作)和内存管理来执行。输出被写回文件或数据库表,作业完成状态通过 JCL 返回码报告。所有这些都在 IBM z/OS 大型机基础设施上运行。

Mainframe architecture with JCL-triggered Assembler batch programs accessing VSAM files and IBM Db2 for z/OS

图 1:大型机 Assembler 架构

目标状态

该现代化解决方案通过多阶段、AI 驱动的工作流,帮助您将遗留大型机 Assembler 应用程序转换为为 AWS 云构建的 Java 应用程序。该架构使用 Amazon Bedrock 和 Kiro IDE 进行 AI 辅助代码分析和业务规则提取,并使用 AWS Transform 进行自动化的 COBOL 到 Java 转换。

如果 COBOL 源代码已经可用,您可以采用常规方法,直接将其提供给 AWS Transform 以转换为 Java Spring Boot 应用程序。

通过此解决方案,您可以实现:

  • 与手动方法相比缩短转换时间。
  • 通过验证检查点系统化地保留业务逻辑。
  • 在关键阶段进行人工参与验证。
  • 自动化代码转换及功能等价测试。
End-to-end AWS workflow transforming Assembler to Java through five phases, from business rules extraction to COBOL-to-Java

图 2:AWS 上的端到端 Assembler 到 Java 转换架构,展示五个主要阶段:业务规则提取、规范驱动的数据流、Assembler 到 COBOL 转换、验证以及 COBOL 到 Java 转换

您通过分析 Assembler 代码来生成业务规则提取(BRE)文档,从而开始转换工作流。然后,您创建详细的功能规格,并进行人工参与的完善。经过验证的规格指导 Assembler 到 COBOL 的转换,生成中间 COBOL 代码,弥合低级硬件指令与面向业务的构造之间的差距。此 COBOL 代码在 AWS Transform 将其转换为 Java 之前会经过功能等价测试,每个阶段都设有验证检查点,以降低风险并验证业务连续性。

使用 AI 提取业务规则

业务规则提取(BRE)的质量直接影响转换准确性,因此请仔细关注此阶段。使用 Amazon Bedrock(通过 Kiro IDE 或 Amazon Bedrock 控制台)以及 AWS Transform for mainframe,从您的 Assembler 源代码中提取并记录业务规则。

您可以通过 Chat Playground直接在 Amazon Bedrock 中使用本文中的提示,或在 Kiro IDE 中使用其内置的 AI 聊天和 Spec 面板。在运行之前,请将占位符值替换为您的实际 Assembler 代码和上下文。

Amazon Bedrock 是前四个阶段的推理平台:业务规则提取、规范创建、Assembler 到 COBOL 转换以及验证。请选择具有强大代码推理能力和大上下文窗口的基础模型,因为 Assembler 程序冗长且密集。将温度设置为 0,以便在多次运行中获得一致的输出。要处理大量程序,请通过 Amazon Bedrock Converse API 调用相同的提示,并将每个输出存储在您的 Amazon S3 存储桶中,以便为下一阶段提供输入。Amazon Bedrock 不会使用您的提示或模型输出来训练 AWS 模型,也不会与第三方共享这些内容。有关详细信息,请参阅 Amazon Bedrock 中的数据保护。请使用经过净化的测试数据,而不是生产数据或个人身份信息(PII)。

您向 AI 提供的上下文越多,它就越能理解代码背后的业务意图。在提示时,请将相关文档、数据字典和可用的业务上下文与 Assembler 代码一并提供。

注意: 请随时保存每个提示的输出。您将在下一阶段将它们用作输入。

上下文感知分析的示例提示:

Extract the business rules and data mappings from this Assembly code.
[PASTE YOUR ASSEMBLY CODE HERE]

## EXTRACT

1.Business Rules: Identify EVERY rule including conditional logic, calculations, validations, transformations, error handling, and loops.

For each rule provide:
- Unique ID (BR001, BR002, etc.)
- Name and description
- Business purpose
- Input fields/registers
- Output fields/registers
- Logic in plain English
- Conditions that trigger the rule

2.Data Mappings: Identify the data transformations with:
- Source field (register or memory location)
- Target field (COBOL variable name)
- Transformation logic
- Validation rules

## RETURN JSON
{  
"program_name": "string",
  "business_rules": [
    {
      "id": "BR001",
      "name": "string",
      "description": "string",
      "purpose": "string",
      "inputs": ["array"],
      "outputs": ["array"],
      "logic": "string",
      "conditions": ["array"]
    }
  ],
  "data_mappings": [
    {
      "source_field": "string",
      "target_field": "string",
      "transformation": "string",
      "validation_rules": ["array"]
    }
  ],
  "summary": "string"
}

您可以通过添加业务上下文中的领域特定术语来自定义此提示。运行此提示时,您将看到结构化 JSON 输出,可用于自动验证以及与下游转换工具直接集成。数据映射准确性直接影响转换质量。不完整的映射可能导致业务逻辑丢失或损坏。

与 SME 一起验证

将 AI 生成的 BRE 文档视为草稿,而非最终输出。在继续之前,请让主题专家审查并验证提取的规则。在验证日志中记录差异,并根据 SME 反馈更新 BRE,然后再进入规范创建阶段。

为帮助 SME 验证规则,请用流程图和数据流图等可视化辅助工具补充文本形式的 BRE 文档。维护一份验证清单,涵盖业务规则准确性、数据映射正确性、边缘情况处理和错误条件完整性。

提取规范驱动的数据流

在与 SME 一起验证业务规则后,将其转化为详细的功能规范,以指导代码转换。这种规范驱动的方法可确认业务需求在代码转换开始前已被清晰记录并达成一致,从而减少后期代价高昂的返工。

使用提取的 BRE 文档创建完整的功能规范,以指导 COBOL 代码生成。这些规范应包括程序概述、COBOL 数据结构、流程设计和业务规则覆盖映射。

功能规范生成的示例提示:

Generate a complete functional specification for COBOL code generation based on the following Business Rules Extraction (BRE).

[PASTE THE BRE JSON HERE]

Create a comprehensive specification including:

## 1. PROGRAM OVERVIEW
- Program purpose and key functionality
- Business rules coverage summary

## 2. COBOL DATA STRUCTURES
Design data structures with:
- COBOL naming: UPPERCASE-WITH-HYPHENS
- Appropriate PIC clauses:
  * PIC 9(n) / S9(n) for integers (S for signed)
  * PIC 9(n)V9(m) / S9(n)V9(m) for decimals
  * PIC X(n) for alphanumeric, PIC A(n) for alphabetic
  * COMP-3 for packed decimal (efficient storage)
- Hierarchical levels (01, 05, 10, 15)
- 88-level condition names for flags

Include:
- The fields from business rules (inputs/outputs)
- The fields from data mappings (source/target)
- Additional fields for calculations, flags, error handling

## 3. PROCESS FLOW DESIGN
Create step-by-step process flow with:
- Sequential procedure steps (initialization → processing → output)
- Decision points and validation steps
- Calculation sequences and error handling

For each step specify:
- Step number and name
- Description
- Business rules implemented (BR IDs)
- Input/output data

## 4. BUSINESS RULES COVERAGE MAP
Map each business rule to:
- Implementation location (procedure/paragraph name)
- Data structures used
- Dependencies on other rules

Return as JSON:
{
  "program_name": "string",
  "overview": "string",
  "data_structures": [
    {
      "name": "WORKING-STORAGE-SECTION",
      "fields": [
        {
          "level": "01",
          "name": "FIELD-NAME",
          "type": "PIC X(10)",
          "description": "string"
        }
      ]
    }
  ],
  "process_flows": [
    {
      "step": 1,
      "name": "PROCEDURE-NAME",
      "description": "string",
      "business_rules": ["BR001"],
      "inputs": ["array"],
      "outputs": ["array"]
    }
  ],
  "business_rules_coverage": {
    "BR001": "Implementation details"
  }
}

您可以根据您的 COBOL 标准调整数据结构规范。运行此提示时,您将收到一份完整的功能规范,其中包含从业务规则到 COBOL 结构的完整可追溯性,可供 SME 审查,并可直接与 Kiro 集成以进行代码生成。

将遗留 Assembler 转换为 COBOL

在获得经过验证的功能规范后,下一阶段将使用这些结构化输出指导 Assembler 到 COBOL 的转换。中间的 COBOL 步骤有助于弥合低级硬件指令与面向业务的构造之间的差距,从而帮助您在最终 Java 转换之前验证业务逻辑是否得到保留。

指导转换的示例提示:

Generate production-ready COBOL code from these specifications.

Program Name: [PROGRAM_NAME]
Assembly Code: [PASTE HERE]
Business Rules (BRE): [PASTE HERE]
Functional Specification: [PASTE HERE]

## REQUIREMENTS
- Implement the business rules from BRE with traceability comments (BR IDs)
- Use exact data structures from specification
- Follow process flow sequence with error handling

## COBOL STRUCTURE
Include: IDENTIFICATION DIVISION (PROGRAM-ID, AUTHOR, DATE-WRITTEN), ENVIRONMENT DIVISION (if needed), DATA DIVISION (WORKING-STORAGE SECTION, FILE/LINKAGE sections if needed), PROCEDURE DIVISION (main paragraph, sub-paragraphs, STOP RUN/GOBACK)

## FORMATTING (STRICT)
Columns 1-6: Sequence numbers (000100, 000200, +100)
Column 7: Indicator (* comment, - continuation, space normal)
Columns 8-11: Area A (Division/Section headers, Paragraphs, Level 01/77)
Columns 12-72: Area B (Level 05-88, statements)

Alignment:
- Level 01/77: Column 8 | Level 05-88: Column 12
- PIC clauses: Column 40 | VALUE clauses: Column 56
- Indent subordinate levels by 4 spaces
- Paragraph names: Column 8 | Statements: Column 12
- Use explicit scope terminators (END-IF, END-PERFORM)

## DATA TYPES
Numeric: PIC 9(n)/S9(n) (integer), PIC 9(n)V9(m)/S9(n)V9(m) (decimal), COMP/BINARY (indexes), COMP-3 (financial)
Alphanumeric: PIC X(n), PIC A(n)
Condition Names: 88-level for flags

## COMMENTS
1.Header(MANDATORY):
000100*****************************************************************
000200* Program: [NAME]                                               *
000300* Purpose: [Description]                                        *
000400* Generated from Assembly using BRE transformation              *
000500* Business Rules: [COUNT] | Data Mappings: [COUNT]              *
000600*****************************************************************

2.Section comments before major sections. 
3.Business rule comments reference BR IDs:
002000* Implements BR001: Validate Input Numbers
002100 VALIDATE-INPUTS.

## IMPLEMENTATION
- Create dedicated paragraph per business rule with BR ID comment
- Implement exact logic from BRE, handle the conditions
- Follow process flow order using PERFORM statements
- Use IF/EVALUATE for decisions, PERFORM UNTIL/VARYING for loops
- Include error handling: validate inputs, check division by zero, verify bounds, set error flags

## OUTPUT FORMAT
CRITICAL: Return ONLY COBOL code. NO explanatory text, NO markdown blocks, NO commentary.
START with sequence-numbered header comment. END with STOP RUN/GOBACK.

您可以修改格式要求,以匹配您组织的 COBOL 标准。运行此提示时,您将生成旨在语法正确、逻辑上等同于原始 Assembler 且完全可追溯的 COBOL 代码,并通过注释将每个代码段链接回 BRE 文档中的特定业务规则。生成后,在进入最终 Java 转换之前,请严格验证 COBOL 代码。

验证转换

您应将测试视为贯穿整个转换过程的持续活动,而不仅仅是最后阶段。Assembler 与 COBOL 代码之间的功能等价验证应采用全面的测试框架,系统性地评估语法正确性、结构一致性、逻辑等价性、数据流完整性、业务规则覆盖率和规范符合性。

指导测试的示例提示:

Perform comprehensive validation and analysis of ASM-to-COBOL translation.

Assembly Code: [PASTE HERE]
COBOL Code: [PASTE HERE]
BRE JSON: [PASTE HERE]
Spec JSON: [PASTE HERE]

## PART 1: VALIDATION

Perform 6 validation checks:

1.Syntax Check: Verify COBOL syntax (divisions, PIC clauses, statements, keywords, column alignment)
   Return: valid (true/false), errors array, warnings array
2.Structure Check: Compare program structure (sections, flow, procedures, control flow, data organization)
   Return: equivalent (true/false), score (0.0-1.0), issues array
3.Logic Check: Verify logic equivalence (conditionals, calculations, loops, error handling, edge cases)
   Return: equivalent (true/false), score (0.0-1.0), differences array
4.Data Flow Check: Verify data transformations (mappings, conversions, I/O, calculations, precision)
   Return: equivalent (true/false), score (0.0-1.0), issues array
5.BRE Coverage Check: Verify the business rules implemented (location, inputs/outputs, conditions)
   Return: coverage_score (0.0-1.0), implemented_rules array, missing_rules array, details object
6.Spec Compliance Check: Verify specification adherence (data structures, process flow, functions, data types)
   Return: compliant (true/false), score (0.0-1.0), issues array

Overall Equivalence Score: Weighted average (Syntax 20%, Structure 20%, Logic 30%, Data Flow 30%, BRE Coverage +10%, Spec Compliance +10%). Status "passed" if ≥0.7.

## PART 2: ANALYSIS

1.Quality Assessment: Classify quality (Excellent ≥0.9, Good ≥0.7, Fair ≥0.5, Poor <0.5) with description and validation status
2.Quality Metrics: Detailed scores for the 6 validation dimensions
3.Improvement Areas: Prioritized list with area name, severity (high/medium/low), issues array, priority (1-5)
4.Recommendations: Actionable suggestions per area (syntax fixes, structure alignment, logic verification, data flow corrections, missing BR implementation, spec compliance)
5.BRE Analysis: Per-rule analysis (rule_id, implemented, location, quality 1-5, deviations, notes) with overall_implementation_quality and summary
6.Code Suggestions: Specific improvements with category (Structure/Naming/Error Handling/Performance/Best Practices), suggestion, location, priority, optional example
7.Executive Summary: Quality level, equivalence score, validation status, improvement areas count, top 3 issues, key recommendations

## OUTPUT FORMAT

Return single JSON with validation and analysis objects. Include the fields: status, equivalence_score, validation_results (the 6 checks), findings, recommendations, quality_assessment, quality_metrics, improvement_areas, bre_analysis, code_suggestions, summary.
CRITICAL: Be thorough, specific (line numbers/paragraphs), actionable, honest (accurate scores), comprehensive (the rules/dimensions). Return JSON only, no explanatory text.
Generate complete validation and analysis report now.

您可以根据质量要求自定义验证阈值。运行此提示时,您将收到一份全面的验证报告,其中包含可操作的建议,用于解决程序结构、条件逻辑、数据转换以及原始 Assembler 指令与现代化 COBOL 实现之间可追溯性方面的差距。

COBOL 到 Java 转换

在最后阶段,您使用 AWS Transform 将经过验证的 COBOL 代码自动转换为 Java Spring Boot 应用程序。借助 AWS Transform 中的智能重构生成生产就绪的 Java 代码。此重构保留了前几个阶段验证的业务逻辑,同时引入现代设计模式,包括依赖注入、存储库模式和服务层。

您可以将生成的 Java 应用程序部署在 AWS 基础设施上,以实现云可扩展性和弹性,同时保持与遗留大型机系统相同的业务功能。这种以云为中心的方法用可独立部署、监控和增强的模块化、可维护代码取代单体大型机架构。

有关详细的分步说明,请参阅 AWS Transform Refactor Workshop.

经验教训

当您在实践中应用此方法时,以下关键经验可以塑造您的方法:

  • 人工参与验证对于转换质量至关重要。 Amazon Bedrock 和 Kiro IDE 可以帮助改进业务规则识别,但 AI 生成的文档应始终被视为草稿。在每个关键阶段,而不仅仅是在提取阶段,SME 审核都至关重要,以捕捉 AI 工具可能忽略的领域特定逻辑、边缘情况和业务上下文。与没有结构化检查点的自动化转换相比,这种人工监督有助于减少部署后缺陷。
  • 中间的 COBOL 步骤可降低风险。 您会发现,在每个阶段都设有验证检查点的多阶段方法(Assembler 到 COBOL 再到 Java)比尝试直接转换更可靠。中间步骤可帮助您在最终确定 Java 转换之前验证业务逻辑是否得到保留。
  • 规范驱动的方法可帮助您防止返工。 在代码转换之前创建详细的功能规范可以及早发现误解。借助结构化 JSON 规范,您还可以自动化验证,并直接与转换工具集成。
  • 增量验证可帮助您加快整体时间线。 在每个转换阶段之后进行测试,而不是等到最后,有助于及早发现问题并减少整体返工。每个阶段的质量门禁有助于确认输出已准备好进入下一阶段。

结论与后续步骤

在本文中,我们介绍了一种系统化、由 AI 驱动的方法,用于将遗留大型机 Assembler 应用程序转换为在 AWS 上为云构建的 Java 应用程序。该方法将用于智能业务逻辑提取的 Amazon Bedrock 和 Kiro IDE 与用于自动化 COBOL 到 Java 转换的 AWS Transform 相结合。通过遵循在每个阶段都设有验证检查点的多阶段方法,您可以帮助加快现代化时间线,同时保持关键业务逻辑的完整性。

要评估完整的服务全景并了解各组件如何协同工作,请从 AWS Mainframe Modernization 文档开始。当您准备好查看流水线实际运行时, AWS Transform Refactor Workshop 将通过您可在自己的环境中运行的示例工作负载,引导您完成端到端流程。如果您想讨论此方法如何应用于您的特定环境,请 联系 AWS 代表.

。告诉我们您的现代化历程,并在评论中分享您的想法。


关于作者