Estendere App per la logica di Azure Agente di migrazione ad altre piattaforme creando parser personalizzati (anteprima)

Si applica a: App per la logica di Azure (Standard)

Se l'organizzazione usa una piattaforma di integrazione che l'estensione App per la logica di Azure Migration Agent in Visual Studio Code attualmente non supporta, ad esempio TIBCO BusinessWorks, IBM IIB/ACE, Dell Boomi o Workato, è possibile estendere l'agente creando e aggiungendo un parser personalizzato per tale piattaforma. L'estensione usa un'architettura del parser basata sul Registro di sistema che supporta parser predefiniti ed esterni, in modo da poter aggiungere il supporto della piattaforma senza modificare la pipeline di migrazione principale.

Questo articolo illustra come creare e aggiungere un parser personalizzato che trasforma gli artefatti della piattaforma di integrazione di origine nel formato common Intermediate Representation (IR) dell'agente di migrazione. Questo documento JSON descrive gli artefatti in modo indipendente dalla piattaforma e consente all'agente di elaborare gli artefatti in tutte le 5 fasi di migrazione.

Prerequisiti

Prima di iniziare, assicurarsi di disporre delle risorse seguenti:

Architettura del parser

Per aggiungere il supporto della piattaforma all'agente di migrazione, usare gli approcci seguenti:

Tutti i parser trasformano gli artefatti della piattaforma di origine in un formato IR comune sotto forma di documento JSON. L'agente di migrazione usa il formato IR nelle fasi di pianificazione, conversione e convalida. Il Registro di sistema del parser supporta plug-in di parser predefiniti ed esterni:

Passaggio 1: Aggiungere un parser predefinito

1. In src/parsers/<your-platform>/creare un nuovo modulo parser.

   src/parsers/
   ├── biztalk/              # Reference implementation
   │   ├── index.ts
   │   ├── types.ts
   │   ├── BizTalkProjectParser.ts
   │   ├── BizTalkOrchestrationParser.ts
   │   └── ...
   ├── <your-platform>/      # Your new parser
   │   ├── index.ts
   │   ├── types.ts
   │   └── <your-platform-parser-name>.ts
   

2. Assicurarsi che ogni parser implementi l'interfaccia IParser .

   import { IParser, ParserCapabilities, ParseResult, ParseOptions } from '../types';
   import { IRDocument, createEmptyIRDocument } from '../../ir/types';
   
   export class YourPlatformParser implements IParser {
       get capabilities(): ParserCapabilities {
           return {
               platform: '<your-platform>',
               fileExtensions: ['.<your-extension>'],
               fileTypes: ['flow'],
               supportsFolder: false,
               description: 'Parses <your-platform> integration flows.',
           };
       }
   
       canParse(filePath: string): boolean {
           return filePath.endsWith('.<your-extension>');
       }
   
       async parse(
           filePath: string,
           options?: ParseOptions
       ): Promise<ParseResult> {
           const ir = createEmptyIRDocument();
           // Parse the source file and populate the IR document.
           // For the complete schema, see docs/IRSchema.md.
           return { ir, stats: { /* parsing statistics */ } };
       }
   }
   

3. Registra il tuo parser in src/parsers/index.ts.

   import { <your-platform-parser-name> } from './<your-platform>';
   
   export function initializeParsers(): void {
       // ... existing parsers ...
       defaultParserRegistry.register(new <your-platform-parser-name>());
   }
   

   Tip

   Come riferimento pienamente funzionante, utilizzare l'implementazione del parser BizTalk in src/parsers/biztalk/.

Passaggio 2: Aggiungere competenze specifiche della piattaforma

Come file Markdown, le competenze forniscono istruzioni di intelligenza artificiale per ogni fase di migrazione. Indicano agli agenti GitHub Copilot come analizzare, pianificare e convertire gli artefatti per la piattaforma specifica.

Per trovare queste competenze, cerca alla voce resources/skills/ con varianti specifiche per piattaforma.

resources/skills/
├── detect-logical-groups/
│   ├── biztalk/SKILL.md
│   ├── mulesoft/SKILL.md
│   └── <your-platform>/SKILL.md
├── source-to-logic-apps-mapping/
│   ├── biztalk/SKILL.md
│   ├── mulesoft/SKILL.md
│   └── <your-platform>/SKILL.md
└── ... (13 skills total)

Ogni SKILL.md file usa frontmatter YAML seguito da contenuto Markdown, ad esempio:

---
name: source-to-logic-apps-mapping
description: >-
   Component mapping for \<*your-platform*\> components to their equivalents in Azure Logic Apps (Standard).
---

Passaggio 3: Eseguire il mapping della piattaforma ai componenti App per la logica di Azure (Standard)

1. Esaminare la tabella seguente per creare le mappature degli adattatori:

   < your-platform> componente	App per la logica di Azure equivalente	Nativo?	Note
   Listener di HTTP	Attivatore HTTP	Sì	Predefinito
   Connettore di database	Connettore SQL Server	Sì	Predefinito

2. Per ogni competenza nella tabella seguente, creare la variante di competenza richiesta <your-platform>/SKILL.md :

   Tip

   Copiare le competenze per una piattaforma supportata, ad esempio biztalk/SKILL.md, come punto di partenza e adattarne il contenuto alla propria piattaforma.

   GitHub agente Copilot	Competenza	Purpose
   @migration-analyser	detect-logical-groups	Regole per il raggruppamento di elementi in gruppi di flussi logici
   @migration-analyser	analyse-source-design	Regole per l'analisi dell'architettura di origine e la generazione di visualizzazioni
   @migration-analyser	dependency-and-decompilation-analysis	Regole per identificare le dipendenze mancanti
   Tutti gli agenti	source-to-logic-apps-mapping	Mapping componente per componente dall'origine alle app per la logica Azure
   @migration-planner	logic-apps-planning-rules	Regole per la generazione di piani di migrazione
   @migration-converter	conversion-task-plan-rules	Regole per la creazione di attività di conversione
   @migration-converter	scaffold-logic-apps-project	Regole per la generazione della struttura del progetto di app per la logica Standard
   @migration-converter	workflow-json-generation-rules	Regole per la generazione di workflow.json file
   @migration-converter	connections-json-generation-rules	Regole per la generazione del connections.json file
   @migration-converter	dotnet-local-functions-logic-apps	Regole per la generazione di .NET funzioni locali
   @migration-converter	no-stubs-code-generation	Regole per garantire che il codice generato sia completo
   @migration-converter	runtime-validation-and-testing	Regole per la convalida e il test di runtime
   @migration-converter	cloud-deployment-and-testing	Regole per la distribuzione e il test cloud

Passaggio 4: Registrare la piattaforma

1. src/types/platforms.ts Nel file aggiungere la piattaforma all'elenco delle piattaforme supportate.

   export type SourcePlatform = 'biztalk' | 'mulesoft' | '<your-platform>';
   
   export const SUPPORTED_PLATFORMS: PlatformInfo[] = [
       // ... existing platforms ...
       {
           id: '<your-platform>',
           label: '<your-platform-name>',
           description: '<your-platform> version <version-number>',
           icon: '$(server)',
           filePatterns: ['.<your-extension>', '.<your-config>'],
       },
   ];
   

2. Nel src/stages/discovery/PlatformDetector.ts file, aggiungi la logica di rilevamento.

3. Nel file src/stages/discovery/SourceFolderService.ts, aggiungere i pattern di file.

Passaggio 5 (facoltativo): Aggiungere esempi IR

Per documentare il modo in cui gli artefatti della piattaforma si mappano allo schema IR, aggiungi un file docs/IRExamples_YourPlatform.md. Gli esempi seguenti esistono e fungono da modelli:

Alternativa: estensione del parser esterno

Le estensioni del parser esterno coprono solo la fase di individuazione dell'agente di migrazione in cui l'agente analizza i file di origine. Le competenze, il rilevamento della piattaforma e la pianificazione e la conversione basate sull'intelligenza artificiale richiedono di contribuire direttamente al repository di GitHub dell'estensione.

Tuttavia, se si preferisce non contribuire direttamente al repository, creare un'estensione Visual Studio Code separata che registra i parser usando l'API del plug-in di analisi:

import * as vscode from 'vscode';

export async function activate(context: vscode.ExtensionContext) {
    const assistant = vscode.extensions.getExtension('microsoft.logicapps-migration-assistant');

    if (assistant) {
        const api = await assistant.activate();
        api.registerParser(new MyPlatformParser(), {
            priority: 10,
        });
    }
}

API del plug-in parser

Contenuti correlati

• automazione della migrazione da piattaforme di integrazione ad App per la logica di Azure

Passaggi successivi