Applicazione e valutazione del codice di Azure Migrate per Java versione 7 (anteprima)

Nota

Questo articolo è destinato alla prossima generazione di applicazioni e valutazione del codice di Azure Migrate per Java, versione 7.x. Questa versione è disponibile in anteprima. Per la versione stabile precedente, versione 6.x, vedere l'applicazione Azure Migrate e la valutazione del codice per Java.

Questo articolo illustra come usare l'applicazione Azure Migrate e lo strumento di valutazione del codice per Java per valutare e riformare qualsiasi tipo di applicazione Java. Lo strumento consente di valutare l'idoneità delle applicazioni per il trasferimento su altre piattaforme e la migrazione ad Azure. Questo strumento viene offerto come interfaccia della riga di comando e valuta i file binari dell'applicazione Java e il codice sorgente per identificare le opportunità di riplatforming e migrazione per Azure. Consente di modernizzare e trasferire su altre piattaforme applicazioni Java su larga scala identificando i casi d'uso e i modelli di codice comuni e proponendo le modifiche consigliate.

Lo strumento individua l'utilizzo della tecnologia delle applicazioni tramite l'analisi statica del codice, fornisce una stima del lavoro e accelera la ripiattaforma del codice. Questa valutazione consente di classificare in ordine di priorità e spostare applicazioni Java in Azure. Con un set di motori e regole, lo strumento può individuare e valutare tecnologie diverse, ad esempio Java 11, Java 17, Jakarta EE, Spring, Hibernate, Java Message Service (JMS) e altro ancora. Lo strumento consente quindi di riformformare l'applicazione Java in destinazioni di Azure diverse, app Azure Servizio, servizio Azure Kubernetes e App Azure Container, con regole di ripiattaforma di Azure specifiche.

Lo strumento si basa su un set di componenti nel progetto Cloud Native Computing Foundation Konveyor, creato e guidato da Red Hat.

Panoramica

Lo strumento è progettato per aiutare le organizzazioni a modernizzare le proprie applicazioni Java in modo da ridurre i costi e consentire un'innovazione più rapida. Lo strumento usa tecniche di analisi avanzate per comprendere la struttura e le dipendenze di qualsiasi applicazione Java e fornisce indicazioni su come effettuare il refactoring e la migrazione delle applicazioni ad Azure.

Lo strumento consente di effettuare le attività seguenti:

Individuare l'utilizzo della tecnologia: vedere rapidamente quali tecnologie usano un'applicazione. L'individuazione è utile se si dispone di applicazioni legacy senza molta documentazione e si vuole sapere quali tecnologie usano.
Valutare il codice in una destinazione specifica: valutare un'applicazione per una destinazione di Azure specifica. Controllare l’impegno e le modifiche da apportare per trasferire le applicazioni da altre piattaforme in Azure.

Destinazioni supportate

Lo strumento contiene regole che consentono di trasferire ad altre piattaforme le applicazioni, in modo da poter distribuire e usare i servizi di Azure seguenti.

Le regole usate dall'applicazione e dalla valutazione del codice di Azure Migrate vengono raggruppate in base a una destinazione. Una destinazione indica dove e come viene eseguita l'applicazione, oltre alle esigenze e alle aspettative generali. Quando si valuta un'applicazione, è possibile scegliere più destinazioni. La tabella seguente descrive le destinazioni disponibili:

Nome di destinazione	Descrizione	Destinazione
Servizio app di Azure	Procedure consigliate per la distribuzione di un'app nel servizio app di Azure.	`azure-appservice`
Servizio Azure Kubernetes	Procedure consigliate per la distribuzione di un'app nel servizio Azure Kubernetes.	`azure-aks`
App contenitore di Azure	Procedure consigliate per la distribuzione di un'app in App contenitore di Azure.	`azure-container-apps`
Idoneità del cloud	Procedure generali consigliate per la preparazione di un'applicazione Cloud (Azure).	`cloud-readiness`
Linux	Procedure generali consigliate per la preparazione di un'applicazione Linux.	`linux`
OpenJDK 11	Procedure generali consigliate per l'esecuzione di un'applicazione Java 8 con Java 11.	`openjdk11`
OpenJDK 17	Procedure generali consigliate per l'esecuzione di un'applicazione Java 11 con Java 17.	`openjdk17`
OpenJDK 21	Procedure generali consigliate per l'esecuzione di un'applicazione Java 17 con Java 21.	`openjdk21`

Quando lo strumento valuta l'idoneità del cloud e dei servizi di Azure correlati, può anche segnalare informazioni utili per il potenziale utilizzo di servizi di Azure diversi. L'elenco seguente mostra alcuni dei servizi offerti:

Database di Azure
Bus di servizio di Azure
Archiviazione di Azure
Rete di distribuzione dei contenuti di Azure
Hub eventi di Azure
Azure Key Vault (Archivio chiavi di Azure)
Frontdoor di Azure

Scaricare e installare

Per usare l'interfaccia della appcat riga di comando, è necessario scaricare il pacchetto specifico dell'ambiente e avere le dipendenze necessarie nell'ambiente. L'interfaccia della appcat riga di comando viene eseguita in qualsiasi ambiente, ad esempio Windows, Linux o Mac, usando l'hardware Intel, Arm o Apple Silicon. Per il requisito JDK, è consigliabile usare Microsoft Build of OpenJDK.

Sistema operativo	Architettura	Collegamento di download	Altri file
x64
Finestre	x64	Scarica	sha256 / sig
macOS	x64	Scarica	sha256 / sig
Linux	x64	Scarica	sha256 / sig
AArch64
Finestre	AArch64/ ARM64	Scarica	sha256 / sig
macOS	Apple Silicon	Scarica	sha256 / sig
Linux	AArch64/ ARM64	Scarica	sha256 / sig

Prerequisiti

Scaricare e installare Microsoft Build di OpenJDK 17. Assicurarsi che la JAVA_HOME variabile di ambiente sia impostata.

Installare AppCAT

Per installare appcat, scaricare il file ZIP appropriato per la piattaforma. Dopo aver scaricato il file, a seconda del sistema operativo, è necessario trovare un .tar.gz (Linux/macOS) o .zip file (Windows).

Estrarre il file binario dal file scaricato. Verrà visualizzata la struttura di cartelle seguente:

/azure-migrate-appcat-for-java-cli-<OS>-<architecture>-<release-version>-preview/
├── appcat.exe (Windows) / appcat (Linux/macOS)
├── samples/
├── fernflower.jar
├── LICENSE
├── NOTICE.txt
├── maven.default.index
├── jdtls/
├── static-report/
├── rulesets/
├── readme.md
└── readme.html

Eseguire AppCAT

Per eseguire appcat da qualsiasi posizione nel terminale, estrarre l'archivio nella posizione desiderata. Aggiornare quindi la PATH variabile di ambiente in modo da includere la directory in cui è stato estratto l'archivio.

Nota

Quando viene chiamato il appcat file binario, cerca innanzitutto le relative dipendenze nella cartella eseguibile specificata nella PATH variabile di ambiente. Se le dipendenze non sono trovate, si ricorre alla home directory dell'utente - ~/.appcat su Linux/Mac o %USERPROFILE%\.appcat su Windows.

Utilizzo

Sottocomandi

AppCAT fornisce due sottocomandi per l'utilizzo:

analyze: eseguire l'analisi del codice sorgente sul codice sorgente di input o su un file binario.
transform: converte le regole XML dalle versioni precedenti (6 e precedenti) al formato YAML usato da questa versione.

Nota

Per gli utenti macOS: se si verifica un errore durante Apple could not verify il tentativo di esecuzione dell'app, è possibile risolvere questo errore usando il comando seguente:

xattr -d -r com.apple.quarantine /path/to/appcat_binary

Ad esempio:

xattr -d -r com.apple.quarantine $HOME/.appcat/appcat

Analizza sottocomando

Il analyze sottocomando consente di eseguire il codice sorgente e l'analisi binaria.

Per analizzare il codice sorgente dell'applicazione, usare il comando seguente:

Linux/macOS
Finestre

./appcat analyze --input=<path-to-source-code> --output=<path-to-output-directory> --target=azure-appservice,cloud-readiness --overwrite

.\appcat.exe analyze --input=<path-to-source-code> --output=<path-to-output-directory> --target=azure-appservice,cloud-readiness --overwrite

Il --input flag deve puntare a una directory del codice sorgente o a un file binario e --output deve puntare a una directory per archiviare i risultati dell'analisi.

Per altre informazioni sui flag di analisi, usare il comando seguente:

Linux/macOS
Finestre

./appcat analyze --help

.\appcat.exe analyze --help

Per controllare le destinazioni disponibili per AppCAT, usare il comando seguente:

Linux/macOS
Finestre

./appcat analyze --list-targets

.\appcat.exe analyze --list-targets

Questo comando produce l'output seguente:

available target technologies:
azure-aks
azure-appservice
azure-container-apps
cloud-readiness
linux
openjdk11
openjdk17
openjdk21

Analisi di più applicazioni

AppCAT supporta più analisi delle applicazioni in base all'esecuzione dei comandi. È possibile fornire un elenco delimitato da virgole dei percorsi di input per il --input flag per analizzare più applicazioni in un singolo comando. La directory di output e il report statico includono i risultati di analisi combinati per tutte le applicazioni.

Per analizzare più applicazioni, usare il comando seguente:

Linux/macOS
Finestre

./appcat analyze --input=<path-to-source-A>,<path-to-source-B>,<path-to-source-C> --output=<path-to-output-ABC> --target=<target-name>

.\appcat.exe analyze --input=<path-to-source-A>,<path-to-source-B>,<path-to-source-C> --output=<path-to-output-ABC> --target=<target-name>

AppCAT consente anche di usare --bulk l'opzione per aggiungere in modo incrementale altre analisi delle applicazioni a una directory di output esistente e a un report statico. Quando si usa l'opzione --bulk , è necessario usarla in modo coerente in tutte le esecuzioni di comandi che scrivono nello stesso output.

Nota

Quando si specificano più percorsi di input, --bulk è abilitato per impostazione predefinita.

Per aggiungere in modo incrementale altre analisi delle applicazioni a un report statico esistente, usare il comando seguente:

Linux/macOS
Finestre

./appcat analyze --input=<path-to-source-A>,<path-to-source-B>,<path-to-source-C> --output=<path-to-output-ABC> --target=<target-name>
./appcat analyze --bulk --input=<path-to-source-D> --output=<path-to-output-ABC> --target=<target-name>
./appcat analyze --bulk --input=<path-to-source-E> --output=<path-to-output-ABC> --target=<target-name>

.\appcat.exe analyze --input=<path-to-source-A>,<path-to-source-B>,<path-to-source-C> --output=<path-to-output-ABC> --target=<target-name>
.\appcat.exe analyze --bulk --input=<path-to-source-D> --output=<path-to-output-ABC>
.\appcat.exe analyze --bulk --input=<path-to-source-E> --output=<path-to-output-ABC>

Trasforma sottocomando

Il transform sottocomando consente di convertire le regole XML precedenti appcat usate nella versione 6.x nel nuovo formato YAML usato da questa versione 7.x.

Per trasformare le regole, usare il comando seguente:

Linux/macOS
Finestre

./appcat transform rules --input=<path-to-xml-rules> --output=<path-to-output-directory>

.\appcat.exe transform rules --input=<path-to-xml-rules> --output=<path-to-output-directory>

Il --input flag deve puntare a un file o a una directory contenente regole XML e il --output flag deve puntare alla directory di output per le regole YAML convertite.

Esempi

Nota

Assicurarsi che le autorizzazioni per i file per gli script nella cartella estratta siano impostate per consentire l'esecuzione.

Nella directory degli esempi è possibile trovare gli script seguenti per eseguire diversi tipi di analisi:

run-assessment: fornisce un report con valutazione del codice e passaggi per la migrazione di Airsonic al servizio app di Azure in Tomcat.
run-assessment-transform-rules: converte le regole XML windup in regole YAML compatibili con analyzer-lsp.
run-assessment-custom-rules: fornisce un report di valutazione del codice usando regole personalizzate (trasformare XML in YAML).
run-assessment-openjdk21: genera un report con valutazione del codice e passaggi per la migrazione di Airsonic a OpenJDK 21.
run-assessment-package-only: produce un report valutando pacchetti specifici.

Questi script sono progettati per essere usati con il progetto di esempio Airsonic-Advanced , un streamer multimediale basato sulla community che consente di accedere e condividere la raccolta musicale.

È possibile clonare manualmente il repository dell'applicazione usando il comando seguente:

git clone https://github.com/airsonic-advanced/airsonic-advanced.git

Dopo la clonazione, specificare il percorso della cartella clonata durante l'esecuzione degli script di valutazione. A seconda del sistema operativo, eseguire lo script appropriato, come illustrato nell'esempio seguente:

Nota

Assicurarsi di aver clonato il progetto Airsonic Advanced in un percorso locale prima di eseguire gli script.

Linux/macOS
Finestre

./samples/run-assessment <path-to-airsonic-advanced>

.\samples\run-assessment.bat <path-to-airsonic-advanced>

I report vengono generati e avviati automaticamente. È possibile trovare i report in .. /samples/report-* (Linux/macOS) o .. \samples\report-* (Windows).

Riepilogo dell'analisi

La pagina di destinazione del report presenta una visualizzazione riepilogativa di tutte le applicazioni analizzate. Da qui è possibile passare ai singoli report dell'applicazione per esplorare i risultati dettagliati.

Il pulsante Ask Copilot nell'angolo superiore destro reindirizza l'utente all'estensione GitHub Copilot App Modernization for Java in Visual Studio Code. Questa estensione fornisce sia la valutazione delle app che la correzione del codice come funzionalità chiave per la migrazione di applicazioni Java ad Azure, basate sulle funzionalità di intelligenza artificiale di AppCAT e GitHub Copilot.

Report di valutazione

Il report di valutazione fornisce un elenco di problemi categorizzato di vari aspetti della preparazione di Azure, della modernizzazione nativa del cloud e java che è necessario risolvere per eseguire correttamente la migrazione dell'applicazione ad Azure.

Ogni problema è categorizzato in base alla gravità - Obbligatorio, Facoltativo o Potenziale - e include il numero di righe di codice interessate.

Le schede Dipendenze e tecnologie visualizzano le librerie e le tecnologie usate all'interno dell'applicazione.

Informazioni dettagliate per un problema specifico

Per ogni problema, è possibile ottenere altre informazioni (dettagli del problema, il contenuto della regola e così via) semplicemente selezionandolo. Si ottiene anche l'elenco di tutti i file interessati da questo problema.

Quindi, per ogni file o classe interessata dal problema, è possibile passare al codice sorgente per evidenziare la riga di codice che ha creato il problema.