

AWS Il servizio di modernizzazione del mainframe (esperienza Managed Runtime Environment) non è più aperto a nuovi clienti. Per funzionalità simili a AWS Mainframe Modernization Service (esperienza Managed Runtime Environment), esplora AWS Mainframe Modernization Service (Self-Managed Experience). I clienti esistenti possono continuare a utilizzare il servizio normalmente. [Per ulteriori informazioni, consulta AWS Modifica della disponibilità di Mainframe Modernization.](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html)

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Tutorial: configurazione della build Rocket Software (precedentemente Micro Focus) per l'applicazione di esempio BankDemo
<a name="tutorial-build-mf"></a>

AWS La modernizzazione del mainframe offre la possibilità di configurare build e pipeline di integration/continuous distribuzione continua (CI/CD) per le applicazioni migrate. Queste build e pipeline utilizzano e forniscono queste funzionalità. AWS CodeBuild AWS CodeCommit AWS CodePipeline CodeBuild è un servizio di compilazione completamente gestito che compila il codice sorgente, esegue test unitari e produce artefatti pronti per l'implementazione. CodeCommit è un servizio di controllo delle versioni che consente di archiviare e gestire in modo privato gli archivi Git nel Cloud. AWS CodePipeline è un servizio di distribuzione continua che consente di modellare, visualizzare e automatizzare i passaggi necessari per il rilascio del software.

Questo tutorial dimostra come compilare il codice sorgente dell'applicazione di BankDemo esempio da Amazon S3 e quindi esportare il codice compilato in Amazon S3. AWS CodeBuild 

AWS CodeBuild è un servizio di integrazione continua completamente gestito che compila il codice sorgente, esegue test e produce pacchetti software pronti per la distribuzione. Con CodeBuild, puoi utilizzare ambienti di compilazione preconfezionati oppure puoi creare ambienti di compilazione personalizzati che utilizzano i tuoi strumenti di compilazione. Questo scenario dimostrativo utilizza la seconda opzione. Consiste in un ambiente di CodeBuild compilazione che utilizza un'immagine Docker preconfezionata.

**Importante**  
Prima di iniziare il progetto di modernizzazione del mainframe, ti consigliamo di informarti sul [AWS Migration Acceleration Program (MAP) for](https://aws.amazon.com/migration-acceleration-program/mainframe/) Mainframe o di [AWS contattare specialisti del mainframe](mailto: mainframe@amazon.com) per conoscere i passaggi necessari per modernizzare un'applicazione mainframe.

**Topics**
+ [Prerequisiti](#tutorial-build-mf-prerequisites)
+ [Passaggio 1: condividi le risorse di compilazione con l' AWS account](#tutorial-build-mf-assets)
+ [Fase 2: creazione di bucket Amazon S3](#tutorial-build-mf-s3)
+ [Passaggio 3: Creare il file delle specifiche di compilazione](#tutorial-build-mf-spec)
+ [Passaggio 4: carica i file sorgente](#tutorial-build-mf-upload)
+ [Fase 5: Creare policy IAM](#tutorial-build-mf-IAM-policy)
+ [Fase 6: Creare un ruolo IAM](#tutorial-build-mf-IAM-role)
+ [Fase 7: collegare le policy IAM al ruolo IAM](#tutorial-build-mf-attach)
+ [Fase 8: Creare il progetto CodeBuild](#tutorial-build-mf-create-project)
+ [Fase 9: Avvia la compilazione](#tutorial-build-mf-start)
+ [Passaggio 10: scarica gli artefatti di output](#tutorial-build-mf-download-output)
+ [Eseguire la pulizia delle risorse](#tutorial-build-mf-clean)

## Prerequisiti
<a name="tutorial-build-mf-prerequisites"></a>

Prima di iniziare questo tutorial, completate i seguenti prerequisiti.
+ Scaricate l'[applicazione BankDemo di esempio](https://d3lkpej5ajcpac.cloudfront.net/demo/mf/BANKDEMO-build.zip) e decomprimetela in una cartella. La cartella di origine contiene i programmi COBOL, i copybook e le definizioni. Contiene anche una cartella JCL come riferimento, sebbene non sia necessario creare JCL. La cartella contiene anche i meta file necessari per la compilazione.
+ **Nella console di modernizzazione del AWS mainframe, scegli Strumenti.** In **Analisi, sviluppo e creazione di risorse**, scegli **Condividi risorse con il mio account AWS**.

## Passaggio 1: condividi le risorse di compilazione con l' AWS account
<a name="tutorial-build-mf-assets"></a>

In questo passaggio, ti assicuri di condividere le risorse di compilazione con il tuo AWS account, specialmente nella regione in cui vengono utilizzate le risorse.

1. Apri la console di modernizzazione AWS del mainframe all'indirizzo. [https://console.aws.amazon.com/m2/](https://us-west-2.console.aws.amazon.com/m2/home?region=us-west-2#/)

1. **Nella barra di navigazione a sinistra, scegli Strumenti.**

1. In **Analisi, sviluppo e creazione di risorse**, scegli **Condividi risorse con il mio AWS account**.

**Importante**  
Devi eseguire questo passaggio una volta in ogni AWS regione in cui intendi eseguire le build.

## Fase 2: creazione di bucket Amazon S3
<a name="tutorial-build-mf-s3"></a>

In questo passaggio, crei due bucket Amazon S3. Il primo è un bucket di input per contenere il codice sorgente e l'altro è un bucket di output per contenere l'output della build. Per ulteriori informazioni, consulta [Creazione, configurazione e utilizzo dei bucket Amazon S3 nella Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html) User *Guide*.

1. Per creare il bucket di input, accedi alla console Amazon S3 e **scegli** Crea bucket.

1. Nella **configurazione generale**, fornisci un nome per il bucket e specifica Regione AWS dove desideri crearlo. Un esempio di nome è`codebuild-regionId-accountId-input-bucket`, `regionId` dov'è il Regione AWS bucket ed `accountId` è il tuo ID. Account AWS 
**Nota**  
Se state creando il bucket in un paese diverso Regione AWS dagli Stati Uniti orientali (Virginia settentrionale), specificate il parametro. `LocationConstraint` Per ulteriori informazioni, consulta [Create Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html) nel *riferimento all'API di Amazon Simple Storage Service*.

1. Conserva tutte le altre impostazioni e scegli **Crea bucket**.

1. Ripeti i passaggi 1-3 per creare il bucket di output. Un esempio di nome è`codebuild-regionId-accountId-output-bucket`, dove si `regionId` trova il Regione AWS bucket e `accountId` il tuo ID. Account AWS 

   Qualunque sia il nome che scegli per questi bucket, assicurati di usarli durante questo tutorial.

## Passaggio 3: Creare il file delle specifiche di compilazione
<a name="tutorial-build-mf-spec"></a>

In questo passaggio, crei un file di specifiche di build,. Questo file fornisce i comandi di compilazione e le relative impostazioni, in formato YAML, per CodeBuild eseguire la build. Per ulteriori informazioni, consulta il [riferimento alle specifiche della build CodeBuild nella Guida per](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html) l'*AWS CodeBuild utente*.

1. Crea un file denominato `buildspec.yml` nella directory che hai decompresso come prerequisito.

1. Aggiungi il seguente contenuto al file e salva. Non sono necessarie modifiche per questo file.

   ```
   version: 0.2
   env:
     exported-variables:
       - CODEBUILD_BUILD_ID
       - CODEBUILD_BUILD_ARN
   phases:
     install:
       runtime-versions:
         python: 3.7
     pre_build:
       commands:
         - echo Installing source dependencies...
         - ls -lR $CODEBUILD_SRC_DIR/source
     build:
       commands:
         - echo Build started on `date`
         - /start-build.sh -Dbasedir=$CODEBUILD_SRC_DIR/source -Dloaddir=$CODEBUILD_SRC_DIR/target 
     post_build:
       commands:
         - ls -lR $CODEBUILD_SRC_DIR/target
         - echo Build completed on `date`
   artifacts:
     files:
       - $CODEBUILD_SRC_DIR/target/**
   ```

   Qui`CODEBUILD_BUILD_ID`, `CODEBUILD_BUILD_ARN``$CODEBUILD_SRC_DIR/source`, e `$CODEBUILD_SRC_DIR/target` ci sono variabili di ambiente disponibili all'interno CodeBuild. Per ulteriori informazioni, consulta [Variabili di ambiente negli ambienti di compilazione](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html).

   A questo punto, la tua directory dovrebbe avere questo aspetto.

   ```
   (root directory name)
       |-- build.xml
       |-- buildspec.yml
       |-- LICENSE.txt
       |-- source
            |... etc.
   ```

1. Comprimi il contenuto della cartella in un file chiamato`BankDemo.zip`.. Per questo tutorial, non puoi comprimere la cartella. Invece, comprimi il contenuto della cartella nel file`BankDemo.zip`.

## Passaggio 4: carica i file sorgente
<a name="tutorial-build-mf-upload"></a>

In questo passaggio, carichi il codice sorgente per l'applicazione di BankDemo esempio nel tuo bucket di input Amazon S3.

1. Accedi alla console Amazon S3 e scegli **Bucket nel riquadro di navigazione** a sinistra. Quindi scegli il bucket di input che hai creato in precedenza.

1. In **Oggetti**, scegli **Carica**.

1. Nella sezione **File e cartelle**, scegli **Aggiungi file**.

1. Vai al tuo `BankDemo.zip` file e scegli.

1. Scegli **Carica**.

## Fase 5: Creare policy IAM
<a name="tutorial-build-mf-IAM-policy"></a>

In questo passaggio, crei due [policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html). Una policy concede le autorizzazioni per AWS Mainframe Modernization per accedere e utilizzare l'immagine Docker che contiene gli strumenti di compilazione di Rocket Software. Questa politica non è personalizzata per i clienti. [L'altra politica concede le autorizzazioni per AWS Mainframe Modernization per interagire con i bucket di input e output e con i log Amazon generati. CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) CodeBuild 

*Per ulteriori informazioni sulla creazione di una policy IAM, consulta [Modifica delle politiche IAM nella IAM User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).*

**Per creare una policy per l'accesso alle immagini Docker**

1. Nella console IAM, copia il seguente documento di policy e incollalo nell'editor delle policy.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "ecr:GetAuthorizationToken"
               ],
               "Resource": "*"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "ecr:BatchCheckLayerAvailability",
                   "ecr:GetDownloadUrlForLayer",
                   "ecr:BatchGetImage"
               ],
               "Resource": "arn:aws:ecr:*:673918848628:repository/m2-enterprise-build-tools"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "s3:PutObject"
               ],
               "Resource": "arn:aws:s3:::aws-m2-repo-*-<region>-prod"
           }
       ]
   }
   ```

------

1. Fornisci un nome per la policy, ad esempio`m2CodeBuildPolicy`.

**Creare una policy che consenta alla modernizzazione AWS del mainframe di interagire con bucket e log**

1. Nella console IAM, copia il seguente documento di policy e incollalo nell'editor delle policy. Assicurati di eseguire l'aggiornamento `regionId` a Regione AWS, e `accountId` al tuo Account AWS.

1. Fornisci un nome per la politica, ad esempio,`BankdemoCodeBuildRolePolicy`.

## Fase 6: Creare un ruolo IAM
<a name="tutorial-build-mf-IAM-role"></a>

In questo passaggio, crei un nuovo [ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) che permetta di CodeBuild interagire con AWS le risorse per te, dopo aver associato le policy IAM che hai creato in precedenza a questo nuovo ruolo IAM.

Per informazioni sulla creazione di un ruolo di servizio, consulta [Creating a Role to Delegate Permissions to an AWS Service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) nella *IAM User Guide*,.

1. Accedi alla console IAM e scegli **Ruoli** nel riquadro di navigazione a sinistra.

1. Scegli **Crea ruolo**.

1. In **Tipo di entità affidabile**, scegli il **servizio AWS**.

1. **In Casi d'uso per altri servizi AWS **CodeBuild****, scegli, quindi scegli di **CodeBuild**nuovo.

1. Scegli **Next (Successivo)**.

1. Nella pagina **Add permissions** (Aggiungi autorizzazioni), scegli **Next** (Successivo). Successivamente assegnerai una policy al ruolo.

1. In **Dettagli del ruolo**, fornisci un nome per il ruolo, `BankdemoCodeBuildServiceRole` ad esempio.

1. In **Seleziona entità attendibili**, verifica che il documento di policy abbia il seguente aspetto:

------
#### [ JSON ]

****  

   ```
   {
             "Version":"2012-10-17",		 	 	 
             "Statement": [
               {
                 "Effect": "Allow",
                 "Principal": {
                   "Service": "codebuild.amazonaws.com"
                 },
                 "Action": "sts:AssumeRole"
               }
             ]
           }
   ```

------

1. Scegli **Crea ruolo**.

## Fase 7: collegare le policy IAM al ruolo IAM
<a name="tutorial-build-mf-attach"></a>

In questo passaggio, colleghi le due policy IAM create in precedenza al ruolo `BankdemoCodeBuildServiceRole` IAM.

1. Accedi alla console IAM e scegli **Roles** nel riquadro di navigazione a sinistra.

1. In **Ruoli**, scegli il ruolo che hai creato in precedenza, ad esempio`BankdemoCodeBuildServiceRole`.

1. In **Criteri di autorizzazione**, scegli **Aggiungi autorizzazioni**, quindi **Allega** criteri.

1. In **Altre politiche di autorizzazione**, scegli le politiche che hai creato in precedenza, ad esempio e. `m2CodeBuildPolicy` `BankdemoCodeBuildRolePolicy`

1. Scegli **Collega policy**.

## Fase 8: Creare il progetto CodeBuild
<a name="tutorial-build-mf-create-project"></a>

In questo passaggio, crei il CodeBuild progetto.

1. Accedi alla CodeBuild console e scegli **Crea progetto di compilazione**.

1. Nella sezione **Configurazione del progetto**, fornisci un nome per il progetto, ad esempio`codebuild-bankdemo-project`.

1. Nella sezione **Sorgente**, per **Provider di origine**, scegli **Amazon S3**, quindi scegli il bucket di input creato in precedenza, ad esempio. `codebuild-regionId-accountId-input-bucket`

1. Nel campo della **chiave dell'oggetto S3 o della cartella S3**, inserisci il nome del file zip che hai caricato nel bucket S3. In questo caso, il nome del file è. `bankdemo.zip`

1. Nella sezione **Ambiente**, scegli **Immagine personalizzata**.

1. Nel campo **Tipo di ambiente**, scegli **Linux**.

1. In **Registro delle immagini**, scegli **Altro registro**.

1. Nel campo **URL del registro esterno**, 
   + Per Rocket Software v9: Invio. `673918848628.dkr.ecr.us-west-1.amazonaws.com/m2-enterprise-build-tools:9.0.7.R1` Se utilizzi una AWS regione diversa con Rocket Software v9, puoi anche specificare dove si trova <m2-region>una AWS regione in cui è disponibile il servizio di modernizzazione del AWS mainframe (ad esempio` 673918848628.dkr.ecr.<m2-region>.amazonaws.com/m2-enterprise-build-tools:9.0.7.R1`,). `eu-west-3`
   + Per Rocket Software v8: Inserisci `673918848628.dkr.ecr.us-west-2.amazonaws.com/m2-enterprise-build-tools:8.0.9.R1`
   + Per Rocket Software v7: Invio `673918848628.dkr.ecr.us-west-2.amazonaws.com/m2-enterprise-build-tools:7.0.R10`

1. In **Ruolo di servizio**, scegli **Ruolo di servizio esistente** e, nel campo **Role ARN**, scegli il ruolo di servizio creato in precedenza, ad esempio. `BankdemoCodeBuildServiceRole`

1. Nella sezione **Buildspec**, scegli **Usa** un file buildspec.

1. Nella sezione **Artefatti**, in **Tipo**, scegli **Amazon S3**, quindi scegli il tuo bucket di output, ad esempio. `codebuild-regionId-accountId-output-bucket`

1. Nel campo **Nome**, inserisci il nome di una cartella nel bucket in cui desideri contenere gli artefatti di output della build, ad esempio. `bankdemo-output.zip`

1. **In **Artifacts** packaging, scegli Zip.**

1. Scegliere **Create build project (Crea progetto di compilazione)**.

## Fase 9: Avvia la compilazione
<a name="tutorial-build-mf-start"></a>

In questo passaggio, si avvia la compilazione.

1. Accedi alla CodeBuild console.

1. Nel riquadro di navigazione a sinistra, scegli **Crea progetti**.

1. Scegli il progetto di compilazione che hai creato in precedenza, ad esempio`codebuild-bankdemo-project`.

1. Selezionare **Start build (Avvia compilazione)**.

Questo comando avvia la compilazione. La build viene eseguita in modo asincrono. L'output del comando è un JSON che include l'attributo id. Questo attributo id è un riferimento all'id di CodeBuild build della build appena avviata. Puoi visualizzare lo stato della build nella CodeBuild console. Puoi anche visualizzare i log dettagliati sull'esecuzione della build nella console. Per ulteriori informazioni, consulta [Visualizza informazioni dettagliate sulla build](https://docs.aws.amazon.com/codebuild/latest/userguide/getting-started-build-log-console.html) nella *Guida per l'AWS CodeBuild utente*.

Quando la fase corrente è COMPLETATA, significa che la build è stata completata correttamente e gli artefatti compilati sono pronti su Amazon S3.

## Passaggio 10: scarica gli artefatti di output
<a name="tutorial-build-mf-download-output"></a>

In questo passaggio, scarichi gli artefatti di output da Amazon S3. Lo strumento di compilazione Rocket Software può creare diversi tipi di eseguibili. In questo tutorial, genera oggetti condivisi.

1. Accedi alla console Amazon S3.

1. Nella sezione **Buckets** role="bold">, scegli il nome del tuo bucket di output, ad esempio,. `codebuild-regionId-accountId-output-bucket`

1. **Scegli Download role="bold">.**

1. Decomprimere il file scaricato. Vai alla cartella di destinazione per vedere gli artefatti della build. Questi includono gli oggetti condivisi di `.so` Linux.

## Eseguire la pulizia delle risorse
<a name="tutorial-build-mf-clean"></a>

Se non ti servono più le risorse che hai creato per questo tutorial, eliminale per evitare costi aggiuntivi. Per fare ciò, completa la seguente procedura:
+ Elimina i bucket S3 che hai creato per questo tutorial. Per ulteriori informazioni, consulta [Eliminazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) nella Guida per l'*utente di Amazon Simple Storage Service*.
+ Elimina le policy IAM che hai creato per questo tutorial. Per ulteriori informazioni, consulta [Eliminazione delle policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-delete.html) nella *IAM User Guide*.
+ Elimina il ruolo IAM che hai creato per questo tutorial. Per ulteriori informazioni, consulta la sezione [Eliminazione di ruoli o profili delle istanze](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html) nella *Guida per l'utente di IAM*.
+ Elimina il CodeBuild progetto che hai creato per questo tutorial. Per ulteriori informazioni, consulta [Eliminare un progetto di compilazione CodeBuild nella](https://docs.aws.amazon.com/codebuild/latest/userguide/delete-project.html) *Guida AWS CodeBuild per l'utente*.