

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 per Rocket Software (in precedenza Micro Focus)
<a name="tutorials-mf"></a>

I tutorial di questa sezione ti aiutano a iniziare a configurare varie attività nel motore di runtime di Rocket Software per il servizio di modernizzazione del AWS mainframe. Questi tutorial riguardano la configurazione di un'applicazione di esempio, l'utilizzo di modelli con Rocket Enterprise Developer e la configurazione di Enterprise Analyzer.

**Topics**
+ [Tutorial: configurazione della build Rocket Software (precedentemente Micro Focus) per l'applicazione di esempio BankDemo](tutorial-build-mf.md)
+ [Tutorial: Configurazione WorkSpaces delle applicazioni da utilizzare con Rocket Enterprise Analyzer e Rocket Enterprise Developer](set-up-appstream-mf.md)
+ [Tutorial: utilizzo dei modelli con Rocket Enterprise Developer (precedentemente Micro Focus Enterprise Developer)](tutorial-templates-ed.md)
+ [Tutorial: configurare Enterprise Analyzer sulle applicazioni WorkSpaces](set-up-ea.md)
+ [Tutorial: configurare Rocket Enterprise Developer sulle applicazioni WorkSpaces](set-up-ed.md)

# 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*.

# Tutorial: Configurazione WorkSpaces delle applicazioni da utilizzare con Rocket Enterprise Analyzer e Rocket Enterprise Developer
<a name="set-up-appstream-mf"></a>

AWS La modernizzazione del mainframe fornisce diversi strumenti tramite Amazon WorkSpaces Applications. WorkSpaces Applications è un servizio di streaming di applicazioni completamente gestito e sicuro che consente di trasmettere applicazioni desktop agli utenti senza riscrivere le applicazioni. WorkSpaces Applications offre agli utenti l'accesso immediato alle applicazioni di cui hanno bisogno con un'esperienza utente reattiva e fluida sul dispositivo di loro scelta. L'utilizzo di WorkSpaces Applications to host di strumenti specifici del motore di runtime offre ai team applicativi dei clienti la possibilità di utilizzare gli strumenti direttamente dai propri browser Web, interagendo con i file delle applicazioni archiviati nei bucket o negli archivi Amazon S3. CodeCommit 

Per informazioni sul supporto del browser nelle WorkSpaces applicazioni, consulta [i requisiti di sistema e il supporto delle funzionalità (browser Web)](https://docs.aws.amazon.com/appstream2/latest/developerguide/requirements-and-features-web-browser-admin.html) nella *Amazon WorkSpaces Applications Administration Guide*. In caso di problemi durante l'utilizzo WorkSpaces delle applicazioni, consulta la sezione [Risoluzione dei problemi degli utenti AppStream 2.0](https://docs.aws.amazon.com/appstream2/latest/developerguide/troubleshooting-user-issues.html) nella *Amazon WorkSpaces Applications Administration Guide*.

Questo documento è destinato ai membri del team operativo dei clienti. Descrive come configurare flotte e stack di Amazon WorkSpaces Applications per ospitare gli strumenti Rocket Enterprise Analyzer e Rocket Enterprise Developer utilizzati con Mainframe Modernization. AWS Rocket Enterprise Analyzer viene solitamente utilizzato durante la fase di valutazione e Rocket Enterprise Developer viene solitamente utilizzato durante la fase di migrazione e modernizzazione dell'approccio di modernizzazione del mainframe. AWS Se si prevede di utilizzare sia Enterprise Analyzer che Enterprise Developer, è necessario creare flotte e stack separati per ogni strumento. Ogni strumento richiede una propria flotta e un proprio stack perché i termini di licenza sono diversi.

**Importante**  
[I passaggi di questo tutorial si basano sul CloudFormation modello scaricabile cfn-m2- .yml. appstream-fleet-ea-ed](https://drm0z31ua8gi7.cloudfront.net/tutorials/mf/appstream/cfn-m2-appstream-fleet-ea-ed.yml) 

**Topics**
+ [Prerequisiti](#tutorial-aas-prerequisites)
+ [Passaggio 1: ottieni le immagini delle WorkSpaces applicazioni](#tutorial-aas-step1)
+ [Passaggio 2: crea lo stack utilizzando il modello CloudFormation](#tutorial-aas-step2)
+ [Passaggio 3: Creare un utente in WorkSpaces Applicazioni](#tutorial-aas-step3)
+ [Fase 4: Accedere alle WorkSpaces applicazioni](#tutorial-aas-step4)
+ [Passaggio 5: verifica i bucket in Amazon S3 (opzionale)](#tutorial-aas-step5)
+ [Fasi successive](#tutorial-aas-next-steps)
+ [Eseguire la pulizia delle risorse](#tutorial-aas-cleanup)

## Prerequisiti
<a name="tutorial-aas-prerequisites"></a>
+ [Scarica il modello: cfn-m2- .yml. appstream-fleet-ea-ed](https://drm0z31ua8gi7.cloudfront.net/tutorials/mf/appstream/cfn-m2-appstream-fleet-ea-ed.yml)
+ Ottieni l'ID del tuo VPC e del tuo gruppo di sicurezza predefiniti. Per ulteriori informazioni sul VPC predefinito, consulta [Default VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) nella Amazon *VPC* User Guide. Per ulteriori informazioni sul gruppo di sicurezza predefinito, consulta [Gruppi di sicurezza predefiniti e personalizzati](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/default-custom-security-groups.html) nella Guida per l'*utente di Amazon EC2*. 
+ Assicurati di disporre delle seguenti autorizzazioni:
  + crea pile, flotte e utenti nelle Applicazioni. WorkSpaces 
  + crea pile CloudFormation utilizzando un modello.
  + crea bucket e carica file nei bucket in Amazon S3.
  + scarica le credenziali (`access_key_id`e`secret_access_key`) da IAM.

## Passaggio 1: ottieni le immagini delle WorkSpaces applicazioni
<a name="tutorial-aas-step1"></a>

In questo passaggio, condividi WorkSpaces le immagini delle applicazioni per Enterprise Analyzer ed Enterprise Developer con il tuo AWS account.

1. Apri la console di modernizzazione del AWS 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**.

## Passaggio 2: crea lo stack utilizzando il modello CloudFormation
<a name="tutorial-aas-step2"></a>

In questo passaggio, utilizzi il CloudFormation modello scaricato per creare uno stack e una flotta di WorkSpaces applicazioni per eseguire Rocket Enterprise Analyzer. Puoi ripetere questo passaggio in seguito per creare un altro stack e un altro parco WorkSpaces applicazioni per eseguire Rocket Enterprise Developer, poiché ogni strumento richiede il proprio parco applicazioni e il proprio stack. WorkSpaces *Per ulteriori informazioni sugli CloudFormation stack, consulta [Working with stacks](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html) nella Guida per l'utente.AWS CloudFormation *

**Nota**  
AWS Mainframe Modernization aggiunge un costo aggiuntivo ai prezzi standard delle WorkSpaces applicazioni per l'uso di Enterprise Analyzer ed Enterprise Developer. Per ulteriori informazioni, consulta [AWS Mainframe](https://aws.amazon.com/mainframe-modernization/pricing/) Modernization Pricing.

1. Scaricate il modello [cfn-m2- appstream-fleet-ea-ed .yml](https://drm0z31ua8gi7.cloudfront.net/tutorials/mf/appstream/cfn-m2-appstream-fleet-ea-ed.yml), se necessario.

1. Apri la CloudFormation console e scegli **Create Stack** e **con nuove** risorse (standard).

1. In **Prerequisito - Prepara modello**, scegli **Il modello è pronto**.

1. In **Specificare il modello**, scegli **Carica un file modello**.

1. In **Carica un file modello**, scegli **Scegli file** e carica il modello [cfn-m2- appstream-fleet-ea-ed .yml](https://drm0z31ua8gi7.cloudfront.net/tutorials/mf/appstream/cfn-m2-appstream-fleet-ea-ed.yml).

1. Scegli **Next (Successivo)**.  
![\[La pagina CloudFormation Crea stack con il modello cfn-m2- .yml selezionato. appstream-fleet-ea-ed\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/cfn-create-stack.png)

1. In **Specificare i dettagli dello stack, inserisci le seguenti informazioni**:
   + Nel **nome dello stack**, inserisci un nome a tua scelta. Ad esempio, **m2-ea**.
   + In **AppStreamApplication**, scegli un **tè**.
   + In **AppStreamFleetSecurityGroup**, scegli il gruppo di sicurezza predefinito del tuo VPC predefinito.
   + In **AppStreamFleetVpcSubnet**, scegli una sottorete all'interno del tuo VPC predefinito.
   + In **AppStreamImageName**, scegli l'immagine che inizia con. `m2-enterprise-analyzer` Questa immagine contiene la versione attualmente supportata dello strumento Rocket Enterprise Analyzer.
   + **Accetta le impostazioni predefinite per gli altri campi, quindi scegli Avanti.**  
![\[La pagina dei dettagli di CloudFormation specificazione dello stack con le opzioni di Enterprise Analyzer è stata compilata.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/cfn-specify-stack-details.png)

1. **Accetta tutte le impostazioni predefinite, quindi scegli nuovamente Avanti.**

1. In **Review**, assicurati che tutti i parametri siano quelli che intendi.

1. Scorri verso il basso, scegli **Riconosco che AWS CloudFormation potrebbe creare risorse IAM con nomi personalizzati** e scegli **Create Stack**.

La creazione dello stack e della flotta richiede dai 20 ai 30 minuti. Puoi scegliere **Aggiorna** per vedere gli CloudFormation eventi man mano che si verificano. 

## Passaggio 3: Creare un utente in WorkSpaces Applicazioni
<a name="tutorial-aas-step3"></a>

Mentre aspetti che la CloudFormation creazione dello stack sia completata, puoi creare uno o più utenti in WorkSpaces Applicazioni. Questi utenti sono coloro che utilizzeranno Enterprise Analyzer nelle WorkSpaces applicazioni. Dovrai specificare un indirizzo e-mail per ogni utente e assicurarti che ogni utente disponga di autorizzazioni sufficienti per creare bucket in Amazon S3, caricare file in un bucket e collegarsi a un bucket per mapparne il contenuto.

1. Apri la console Applicazioni. WorkSpaces 

1. Nella barra di navigazione a sinistra, scegli **User pool**.

1. Selezionare **Create user (Crea utente)**.

1. Fornisci un indirizzo e-mail a cui l'utente possa ricevere un invito via e-mail a utilizzare WorkSpaces le applicazioni, un nome e cognome e scegli **Crea utente**.

1. Ripeti l'operazione se necessario per creare altri utenti. L'indirizzo e-mail di ogni utente deve essere univoco.

Per ulteriori informazioni sulla creazione di utenti WorkSpaces delle applicazioni, consulta [WorkSpaces Applications User Pools](https://docs.aws.amazon.com/appstream2/latest/developerguide/user-pool.html) nella *Amazon WorkSpaces Applications Administration Guide*.

Al CloudFormation termine della creazione dello stack, puoi assegnare l'utente che hai creato allo stack, come segue:

1. Apri la console Applicazioni. WorkSpaces 

1. Scegli il nome utente.

1. Scegli **Azione**, quindi **Assegna stack**.

1. In **Assegna stack, scegli lo stack** che inizia con. `m2-appstream-stack-ea`

1. Scegliere **Assign stack (Assegna stack)**.  
![\[La pagina WorkSpaces Applications Assign stack che mostra un utente e lo stack Enterprise Analyzer da assegnare.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/aas-assign-stack.png)

L'assegnazione di un utente a uno stack fa sì che WorkSpaces Applications invii un'e-mail all'utente all'indirizzo fornito. Questa e-mail contiene un collegamento alla pagina di accesso alle WorkSpaces Applicazioni.

## Fase 4: Accedere alle WorkSpaces applicazioni
<a name="tutorial-aas-step4"></a>

In questo passaggio, accedi alle WorkSpaces Applicazioni utilizzando il link contenuto nell'e-mail inviata da WorkSpaces Applications all'utente in cui hai creato[Passaggio 3: Creare un utente in WorkSpaces Applicazioni](#tutorial-aas-step3).

1. Accedi alle WorkSpaces Applicazioni utilizzando il link fornito nell'e-mail inviata dalle WorkSpaces Applicazioni.

1. Cambia la password, se richiesto. La schermata WorkSpaces Applicazioni che vedi è simile alla seguente:  
![\[Una schermata di accesso WorkSpaces alle applicazioni di esempio che mostra l'icona del desktop.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/aas-login-screen.png)

1. Scegli **Desktop**.

1. Sulla barra delle applicazioni, scegli **Cerca** ed entra **D:** per accedere alla cartella Home.
**Nota**  
Se salti questo passaggio, potresti ricevere un `Device not ready` errore quando tenti di accedere alla cartella Home.

In qualsiasi momento, se riscontri problemi di accesso WorkSpaces alle Applicazioni, puoi riavviare il parco WorkSpaces Applicazioni e riprovare ad accedere, utilizzando la procedura seguente.

1. Apri la console WorkSpaces Applicazioni.

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

1. Scegli la flotta che stai cercando di utilizzare.

1. Scegli **Azione**, quindi scegli **Stop**.

1. Attendi che la flotta si fermi.

1. Scegli **Azione**, quindi scegli **Avvia**.

Questo processo può richiedere circa 10 minuti.

## Passaggio 5: verifica i bucket in Amazon S3 (opzionale)
<a name="tutorial-aas-step5"></a>

Una delle attività completate dal CloudFormation modello utilizzato per creare lo stack è stata la creazione di due bucket in Amazon S3, necessari per salvare e ripristinare i dati utente e le impostazioni delle applicazioni tra le sessioni di lavoro. Questi bucket sono i seguenti:
+ Il nome inizia con`appstream2-`. Questo bucket mappa i dati nella cartella Home in WorkSpaces Applicazioni (`D:\PhotonUser\My Files\Home Folder`).
**Nota**  
La cartella Home è unica per un determinato indirizzo e-mail ed è condivisa tra tutte le flotte e gli stack di un determinato account. AWS Il nome della Home Folder è un SHA256 hash dell'indirizzo e-mail dell'utente ed è memorizzato in un percorso basato su tale hash.
+ Il nome inizia con. `appstream-app-settings-` Questo bucket contiene informazioni sulla sessione utente per WorkSpaces le applicazioni e include impostazioni come i preferiti del browser, i profili di connessione IDE e delle applicazioni e le personalizzazioni dell'interfaccia utente. Per ulteriori informazioni, consulta [How Application Settings Persistence Works](https://docs.aws.amazon.com/appstream2/latest/developerguide/how-it-works-app-settings-persistence.html) nella *Amazon WorkSpaces Applications Administration Guide*.

Per verificare che i bucket siano stati creati, segui questi passaggi:

1. Apri la console Amazon S3.

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

1. In **Trova i bucket per nome**, inserisci **appstream** per filtrare l'elenco.

Se vedi i bucket, non sono necessarie ulteriori azioni. Tieni solo presente che i bucket esistono. Se non vedi i bucket, significa che l'esecuzione del CloudFormation modello non è terminata o si è verificato un errore. Vai alla CloudFormation console e rivedi i messaggi di creazione dello stack.

## Fasi successive
<a name="tutorial-aas-next-steps"></a>

Ora che l'infrastruttura WorkSpaces delle applicazioni è configurata, è possibile configurarla e iniziare a utilizzare Enterprise Analyzer. Per ulteriori informazioni, consulta [Tutorial: configurare Enterprise Analyzer sulle applicazioni WorkSpaces](set-up-ea.md). È inoltre possibile configurare Enterprise Developer. Per ulteriori informazioni, consulta [Tutorial: configurare Rocket Enterprise Developer sulle applicazioni WorkSpaces](set-up-ed.md).

## Eseguire la pulizia delle risorse
<a name="tutorial-aas-cleanup"></a>

La procedura per ripulire lo stack e le flotte creati è descritta in [Creare un parco macchine e uno stack di WorkSpaces applicazioni](https://docs.aws.amazon.com/appstream2/latest/developerguide/set-up-stacks-fleets.html).

Quando gli oggetti WorkSpaces Applications sono stati eliminati, l'amministratore dell'account può anche, se necessario, pulire i bucket Amazon S3 per le impostazioni delle applicazioni e le cartelle home.

**Nota**  
La cartella home di un determinato utente è unica per tutte le flotte, quindi potrebbe essere necessario conservarla se nello stesso account sono attivi altri stack di WorkSpaces applicazioni.

Infine, attualmente WorkSpaces Applications non consente di eliminare gli utenti utilizzando la console. È invece necessario utilizzare l'API del servizio con la CLI. Per ulteriori informazioni, consulta [User Pool Administration](https://docs.aws.amazon.com/appstream2/latest/developerguide/user-pool-admin.html) nella *Amazon WorkSpaces Applications Administration Guide*.

# Tutorial: utilizzo dei modelli con Rocket Enterprise Developer (precedentemente Micro Focus Enterprise Developer)
<a name="tutorial-templates-ed"></a>

Questo tutorial descrive come utilizzare modelli e progetti predefiniti con Rocket Enterprise Developer. Copre tre casi d'uso. Tutti i casi d'uso utilizzano il codice di esempio fornito nell' BankDemo esempio. Per scaricare l'esempio, scegli [https://d1vi4vxke6c2hu.cloudfront.net/demo/bankdemo.zip](https://d1vi4vxke6c2hu.cloudfront.net/demo/bankdemo.zip).

**Importante**  
Se utilizzate la versione di Enterprise Developer per Windows, i file binari generati dal compilatore possono essere eseguiti solo sull'Enterprise Server fornito con Enterprise Developer. Non è possibile eseguirli nel runtime AWS Mainframe Modernization, che è basato su Linux.

**Topics**
+ [Caso d'uso 1: utilizzo del modello di progetto COBOL contenente i componenti di origine](#tutorial-templates-ed-step1)
+ [Caso d'uso 2: utilizzo del modello di progetto COBOL senza componenti di origine](#tutorial-templates-ed-step2)
+ [Caso d'uso 3: utilizzo del progetto COBOL predefinito che si collega alle cartelle di origine](#tutorial-templates-ed-step3)
+ [Utilizzo del modello JSON Region Definition](#tutorial-templates-ed-step4)

## Caso d'uso 1: utilizzo del modello di progetto COBOL contenente i componenti di origine
<a name="tutorial-templates-ed-step1"></a>

Questo caso d'uso richiede la copia dei componenti di origine nella struttura di directory Template come parte dei passaggi preliminari alla configurazione dimostrativa. Nel frattempo [https://d1vi4vxke6c2hu.cloudfront.net/demo/bankdemo.zip](https://d1vi4vxke6c2hu.cloudfront.net/demo/bankdemo.zip)questo è stato modificato rispetto alla versione originale `AWSTemplates.zip` per evitare di avere due copie del codice sorgente.

1. Avvia Enterprise Developer e specifica l'area di lavoro scelta.  
![\[Il programma di avvio di Eclipse con un'area di lavoro selezionata.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc1-step1.png)

1. Nella vista **Application Explorer**, dalla voce di visualizzazione ad albero di **Enterprise Development Project**, scegliete **Nuovo progetto da modello dal menu** contestuale.  
![\[Il menu contestuale della visualizzazione ad albero del progetto di sviluppo aziendale.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc1-step2.png)

1. Immettete i parametri del modello come mostrato.
**Nota**  
Il percorso del modello farà riferimento a dove è stato estratto lo ZIP.  
![\[La casella Inserisci i parametri del modello con il percorso e il nome del progetto compilati.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc1-step3.png)

1. Scegliendo OK verrà creato un progetto Eclipse di sviluppo locale basato sul modello fornito, con una struttura completa di origine e ambiente di esecuzione.  
![\[Il progetto di sviluppo locale Eclipse che mostra la sua struttura.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc1-step4.png)

   La `System` struttura contiene un file completo di definizione delle risorse con le voci richieste per BANKDEMO, il catalogo richiesto con le voci aggiunte e i corrispondenti file di dati ASCII.

   Poiché la struttura del modello di origine contiene tutti gli elementi di origine, questi file vengono copiati nel progetto locale e quindi vengono automaticamente integrati in Enterprise Developer.

## Caso d'uso 2: utilizzo del modello di progetto COBOL senza componenti di origine
<a name="tutorial-templates-ed-step2"></a>

I passaggi da 1 a 3 sono identici a. [Caso d'uso 1: utilizzo del modello di progetto COBOL contenente i componenti di origine](#tutorial-templates-ed-step1) 

La `System` struttura in questo caso d'uso contiene anche un file completo di definizione delle risorse con le voci richieste per BankDemo, il catalogo richiesto con le voci aggiunte e i corrispondenti file di dati ASCII.

Tuttavia, la struttura di origine del modello non contiene alcun componente. È necessario importarli nel progetto da qualsiasi repository di origine che si stia utilizzando.

1. Scegli il nome del progetto. Dal menu contestuale correlato, scegliete **Importa**.  
![\[Il menu contestuale del progetto con importazione selezionata.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc2-step4.png)

1. Nella finestra di dialogo risultante, nella sezione **Generale**, scegliete **File System**, quindi scegliete Avanti.  
![\[La casella Importa con il file system selezionato.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc2-step5.png)

1. **Compila il campo Dalla directory** sfogliando il file system in modo che punti alla cartella del repository. Scegli tutte le cartelle che desideri importare, ad esempio. `sources` Il `Into folder` campo verrà precompilato. Scegli **Fine**.   
![\[La casella File system con la BankDemo directory espansa.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc2-step6.png)

   Dopo che la struttura del modello di origine contiene tutti gli elementi di origine, questi vengono creati automaticamente in Enterprise Developer.

## Caso d'uso 3: utilizzo del progetto COBOL predefinito che si collega alle cartelle di origine
<a name="tutorial-templates-ed-step3"></a>

1. Avvia Enterprise Developer e specifica l'area di lavoro scelta.  
![\[Il programma di avvio di Eclipse con un'area di lavoro selezionata.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc3-step1.png)

1. Dal menu **File** scegliere **Import (Importa)**.  
![\[Il menu File con l'opzione Importa selezionata.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc3-step2.png)

1. Nella finestra di dialogo risultante, in **Generale**, scegli **Progetti da cartella o Archivio** e scegli **Avanti**.  
![\[La casella Importa con i progetti selezionati dalla cartella o dall'archivio.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc3-step3.png)

1. Compilate la **sorgente di importazione**, scegliete **Directory** e sfogliate il file system per selezionare la cartella di progetto predefinita. Il progetto contenuto all'interno contiene collegamenti alle cartelle di origine nello stesso repository.  
![\[I progetti di importazione dal file system o dalla casella di archiviazione con il percorso della fonte di importazione immesso.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-uc3-step4.png)

   Scegli **Fine**.

   Poiché il progetto è popolato dai collegamenti alla cartella di origine, il codice viene creato automaticamente.

## Utilizzo del modello JSON Region Definition
<a name="tutorial-templates-ed-step4"></a>

1. Passa alla visualizzazione Server Explorer. Dal menu contestuale correlato, scegliete **Apri pagina di amministrazione**, che avvia il browser predefinito.  
![\[Il menu contestuale di Server Explorer con la pagina di amministrazione aperta selezionata.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-json-admin-page.png)

1. Dalla schermata risultante di Enterprise Server Common Web Administration (ESCWA), scegliete **Importa**.  
![\[La schermata Enterprise Server Common Web Administration con l'opzione Importa selezionata.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-json-import.png)

1. Scegli il tipo di importazione **JSON** e scegli **Avanti**.  
![\[La casella Scegli il tipo di importazione con JSON selezionato.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-json-import-type.png)

1. Carica il `BANKDEMO.JSON` file fornito.  
![\[La casella di selezione del file da caricare con il file BANKDEMO selezionato.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-json-upload.png)

   Una volta selezionato, scegli **Avanti**.  
![\[La casella di selezione delle regioni con le porte cancellate dagli endpoint non selezionate.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-json-next.png)

   Nel pannello **Seleziona regioni**, assicuratevi che l'opzione **Cancella porte dagli endpoints** non sia selezionata, quindi continuate a scegliere **Avanti** tra i pannelli finché non viene visualizzato il pannello **Esegui importazione**. Quindi scegliete **Importa** dal riquadro di navigazione a sinistra.

   Infine, fai clic su **Fine**. La regione BANKDEMO verrà quindi aggiunta all'elenco dei server.  
![\[La regione e l'elenco dei server sono BankDemo stati aggiunti.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-json-server-list.png)

1. Vai alle **Proprietà generali** della regione BANKDEMO.

1. Scorri fino alla sezione **Configurazione**.

1. La variabile di ambiente ESP deve essere impostata sulla `System` cartella relativa al progetto Eclipse creato nei passaggi precedenti. Questo dovrebbe essere. `workspacefolder/projectname/System`  
![\[La sezione di configurazione con la variabile ESP mostrata.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-json-ESP.png)

1. Fare clic su **Apply (Applica)**.

   La regione è ora completamente configurata per funzionare insieme al progetto Eclipse COBOL.

1. Infine, tornando in Enterprise Developer, associate la regione importata al progetto.  
![\[Il menu contestuale del progetto con Associato al progetto selezionato.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ed-json-associate.png)

   L'ambiente Enterprise Developer è ora pronto per l'uso, con una versione funzionante completa di BankDemo. È possibile modificare, compilare ed eseguire il debug del codice in base alla regione.
**Importante**  
Se si utilizza la versione di Enterprise Developer per Windows, i file binari generati dal compilatore possono essere eseguiti solo sull'Enterprise Server fornito con Enterprise Developer. Non è possibile eseguirli nel runtime AWS Mainframe Modernization, che è basato su Linux.

# Tutorial: configurare Enterprise Analyzer sulle applicazioni WorkSpaces
<a name="set-up-ea"></a>

Questo tutorial descrive come configurare Rocket Enterprise Analyzer (precedentemente Micro Focus Enterprise Analyzer) per analizzare una o più applicazioni mainframe. Lo strumento Enterprise Analyzer fornisce diversi report basati sull'analisi del codice sorgente dell'applicazione e delle definizioni di sistema.

Questa configurazione è progettata per favorire la collaborazione in team. L'installazione utilizza un bucket Amazon S3 per condividere il codice sorgente con dischi virtuali. In questo modo si utilizza [Rclone](https://rclone.org/) () sul computer Windows. Con un'istanza Amazon RDS comune che esegue [PostgreSQL](https://www.postgresql.org/), qualsiasi membro del team può accedere a tutti i report richiesti.

I membri del team possono anche montare il disco virtuale con backup di Amazon S3 sui propri computer personali e aggiornare il bucket di origine dalle proprie workstation. Possono potenzialmente utilizzare script o qualsiasi altra forma di automazione sui propri computer se sono collegati ad altri sistemi interni locali.

La configurazione si basa sulle immagini Windows delle WorkSpaces applicazioni che AWS Mainframe Modernization condivide con il cliente. L'installazione si basa inoltre sulla creazione di flotte e stack di WorkSpaces applicazioni, come descritto in. [Tutorial: Configurazione WorkSpaces delle applicazioni da utilizzare con Rocket Enterprise Analyzer e Rocket Enterprise Developer](set-up-appstream-mf.md)

**Importante**  
[I passaggi di questo tutorial presuppongono la configurazione WorkSpaces delle applicazioni con il CloudFormation modello scaricabile cfn-m2- .yml. appstream-fleet-ea-ed](https://drm0z31ua8gi7.cloudfront.net/tutorials/mf/appstream/cfn-m2-appstream-fleet-ea-ed.yml) Per ulteriori informazioni, consulta [Tutorial: Configurazione WorkSpaces delle applicazioni da utilizzare con Rocket Enterprise Analyzer e Rocket Enterprise Developer](set-up-appstream-mf.md).  
Per eseguire i passaggi descritti in questo tutorial, è necessario aver configurato la flotta e lo stack di Enterprise Analyzer e devono essere in esecuzione.

Per una descrizione completa delle funzionalità e dei risultati di Enterprise Analyzer, consultate la [documentazione di Enterprise Analyzer](https://www.microfocus.com/documentation/enterprise-analyzer/) sul sito Web di Rocket Software (precedentemente Micro Focus).

## Contenuto dell'immagine
<a name="set-up-ea-image-contents"></a>

Oltre all'applicazione Enterprise Analyzer stessa, l'immagine contiene i seguenti strumenti e librerie.

Strumenti di terze parti
+ [Python](https://www.python.org/)
+ [Reclone](https://rclone.org/)
+ [pgAdmin](https://www.pgadmin.org/)
+ [gitscm](https://git-scm.com/)
+ [Driver ODBC PostgreSQL](https://odbc.postgresql.org/)

Librerie in `C:\Users\Public`
+ BankDemo codice sorgente e definizione del progetto per Enterprise Developer:`m2-bankdemo-template.zip`.
+ Pacchetto di installazione MFA per il mainframe:. `mfa.zip` Per ulteriori informazioni, vedere [Mainframe Access Overview](https://www.microfocus.com/documentation/enterprise-developer/30pu12/ED-VS2012/BKMMMMINTRS001.html) nella documentazione di *Micro Focus Enterprise* Developer.
+ File di comando e configurazione per Rclone (istruzioni per il loro utilizzo nei tutorial): e. `m2-rclone.cmd` `m2-rclone.conf`

**Topics**
+ [Contenuto dell'immagine](#set-up-ea-image-contents)
+ [Prerequisiti](#tutorial-ea-prerequisites)
+ [Fase 1: configurazione](#tutorial-ea-step1)
+ [Fase 2: creare la cartella virtuale basata su Amazon S3 su Windows](#tutorial-ea-step2)
+ [Fase 3: creare una fonte ODBC per l'istanza Amazon RDS](#tutorial-ea-step3)
+ [Sessioni successive](#tutorial-ea-step4)
+ [Risoluzione dei problemi di connessione all'area di lavoro](#tutorial-ea-step5)
+ [Eseguire la pulizia delle risorse](#tutorial-ea-clean)

## Prerequisiti
<a name="tutorial-ea-prerequisites"></a>
+ Carica il codice sorgente e le definizioni di sistema per l'applicazione del cliente che desideri analizzare in un bucket S3. Le definizioni di sistema includono CICS CSD, definizioni di DB2 oggetti e così via. È possibile creare una struttura di cartelle all'interno del bucket adatta al modo in cui si desidera organizzare gli elementi dell'applicazione. Ad esempio, quando decomprimete l' BankDemo esempio, ha la seguente struttura:

  ```
  demo
       |--> jcl
       |--> RDEF
       |--> transaction
       |--> xa
  ```
+ Crea e avvia un'istanza Amazon RDS che esegue PostgreSQL. Questa istanza memorizzerà i dati e i risultati prodotti da Enterprise Analyzer. È possibile condividere questa istanza con tutti i membri del team dell'applicazione. Inoltre, create uno schema vuoto chiamato `m2_ea` (o qualsiasi altro nome adatto) nel database. Definisci le credenziali per gli utenti autorizzati che consentono loro di creare, inserire, aggiornare ed eliminare elementi in questo schema. Puoi ottenere il nome del database, l'URL dell'endpoint del server e la porta TCP dalla console Amazon RDS o dall'amministratore dell'account.
+ Assicurati di aver configurato l'accesso programmatico al tuo. Account AWS*Per ulteriori informazioni, vedere [Accesso programmatico](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys) in.Riferimenti generali di Amazon Web Services*

## Fase 1: configurazione
<a name="tutorial-ea-step1"></a>

1. Avvia una sessione con WorkSpaces Applications con l'URL che hai ricevuto nel messaggio e-mail di benvenuto inviato da WorkSpaces Applications.

1. Usa la tua e-mail come ID utente e definisci la tua password permanente.

1. Seleziona lo stack Enterprise Analyzer.

1. Nella pagina del menu WorkSpaces Applicazioni, scegli **Desktop** per accedere al desktop Windows su cui è in streaming la flotta.

## Fase 2: creare la cartella virtuale basata su Amazon S3 su Windows
<a name="tutorial-ea-step2"></a>

**Nota**  
Se hai già utilizzato Rclone durante l'anteprima di AWS Mainframe Modernization, devi eseguire l'aggiornamento `m2-rclone.cmd` alla versione più recente disponibile in. `C:\Users\Public`

1. Copia i `m2-rclone.cmd` file `m2-rclone.conf` and forniti nella tua cartella home usando File `C:\Users\Public` Explorer. `C:\Users\PhotonUser\My Files\Home Folder`

1. Aggiorna i parametri di `m2-rclone.conf` configurazione con la tua chiave di AWS accesso e il segreto corrispondente, oltre al tuo Regione AWS.

   ```
   [m2-s3]
   type = s3
   provider = AWS
   access_key_id = YOUR-ACCESS-KEY
   secret_access_key = YOUR-SECRET-KEY
   region = YOUR-REGION
   acl = private
   server_side_encryption = AES256
   ```

1. In `m2-rclone.cmd`, apporta le seguenti modifiche:
   + Cambia `amzn-s3-demo-bucket` il nome del tuo bucket Amazon S3. Ad esempio, `m2-s3-mybucket`.
   + Passa `your-s3-folder-key` alla tua bucket key Amazon S3. Ad esempio, `myProject`.
   + Passa `your-local-folder-path` al percorso della directory in cui desideri sincronizzare i file dell'applicazione dal bucket Amazon S3 che li contiene. Ad esempio, `D:\PhotonUser\My Files\Home Folder\m2-new`. Questa directory sincronizzata deve essere una sottodirectory della cartella Home per consentire alle WorkSpaces applicazioni di eseguire correttamente il backup e il ripristino all'inizio e alla fine della sessione.

   ```
   :loop
   timeout /T 10
   "C:\Program Files\rclone\rclone.exe" sync m2-s3:amzn-s3-demo-bucket/your-s3-folder-key "D:\PhotonUser\My Files\Home Folder\your-local-folder-path" --config "D:\PhotonUser\My Files\Home Folder\m2-rclone.conf"
   goto :loop
   ```

1. Apri un prompt dei comandi di Windows, cd to `C:\Users\PhotonUser\My Files\Home Folder` se necessario ed esegui. `m2-rclone.cmd` Questo script di comandi esegue un ciclo continuo, sincronizzando il bucket e la chiave Amazon S3 con la cartella locale ogni 10 secondi. Puoi regolare il timeout in base alle tue esigenze. Dovresti vedere il codice sorgente dell'applicazione che si trova nel bucket Amazon S3 in Windows File Explorer.

Per aggiungere nuovi file al set su cui stai lavorando o aggiornare quelli esistenti, carica i file nel bucket Amazon S3 e verranno sincronizzati con la tua directory alla successiva iterazione definita in. `m2-rclone.cmd` Allo stesso modo, se desideri eliminare alcuni file, eliminali dal bucket Amazon S3. La prossima operazione di sincronizzazione li eliminerà dalla directory locale.

## Fase 3: creare una fonte ODBC per l'istanza Amazon RDS
<a name="tutorial-ea-step3"></a>

1. **Per avviare lo strumento EA\$1Admin, accedi al menu di selezione delle applicazioni nell'angolo superiore sinistro della finestra del browser e scegli MF EA\$1Admin.**

1. ****Dal menu **Amministra**, scegliete **Origini dati ODBC** e scegliete Aggiungi dalla scheda DSN utente.****

1. **Nella finestra di dialogo Crea nuova origine dati, scegli il driver Unicode **PostgreSQL, quindi** scegli Fine.**

1. Nella finestra di dialogo Configurazione **PostgreSQL Unicode ODBC Driver (pSQLOdBC), definisci e prendi nota** del nome dell'origine dati che desideri. Completa i seguenti parametri con i valori dell'istanza RDS creata in precedenza:  
**Description**  
Descrizione opzionale per aiutarti a identificare rapidamente questa connessione al database.  
**Database**  
Il database Amazon RDS che hai creato in precedenza.  
**Server**  
L'endpoint Amazon RDS.  
**Porta**  
La porta Amazon RDS.  
**Nome utente**  
Come definito nell'istanza Amazon RDS.  
**Password**  
Come definito nell'istanza Amazon RDS.

1. Scegli **Test per verificare** che la connessione ad Amazon RDS sia riuscita, quindi scegli **Salva per salvare** il tuo nuovo DSN utente.

1. Attendi di visualizzare il messaggio che conferma la creazione dell'area di lavoro corretta, quindi scegli **OK** per terminare con ODBC Data Sources e chiudere lo strumento EA\$1Admin.

1. Passate nuovamente al menu di selezione dell'applicazione e scegliete Enterprise Analyzer per avviare lo strumento. Scegliete **Crea nuovo**. 

1. Nella finestra di configurazione dell'area di lavoro, inserisci il nome dell'area di lavoro e definisci la sua posizione. L'area di lavoro può essere il disco basato su Amazon S3 se utilizzi questa configurazione o la cartella home se preferisci.

1. Scegli **Scegli altro database** per connetterti alla tua istanza Amazon RDS.

1. **Scegli l'icona **Postgre** tra le opzioni, quindi scegli OK.**

1. Per le impostazioni di Windows in **Opzioni — Definisci parametri di connessione**, inserisci il nome della fonte di dati che hai creato. Immettete anche il nome del database, il nome dello schema, il nome utente e la password. Scegli **OK**.

1. Attendi che Enterprise Analyzer crei tutte le tabelle, gli indici e così via per memorizzare i risultati. Questo processo potrebbe richiedere un paio di minuti. Enterprise Analyzer conferma quando il database e l'area di lavoro sono pronti per l'uso.

1. Passate nuovamente al menu di selezione dell'applicazione e scegliete Enterprise Analyzer per avviare lo strumento.

1. La finestra di avvio di Enterprise Analyzer viene visualizzata nella nuova posizione selezionata dell'area di lavoro. Scegli **OK**.

1. Accedere al repository nel riquadro di sinistra, selezionare il nome del repository e scegliere **Aggiungi file/cartelle allo spazio di lavoro. Seleziona la** cartella in cui è memorizzato il codice dell'applicazione per aggiungerlo all'area di lavoro. Se lo desideri, puoi utilizzare il codice di BankDemo esempio precedente. Quando Enterprise Analyzer richiede di verificare tali file, scegliete Verifica per avviare il rapporto di **verifica** iniziale di Enterprise Analyzer. Il completamento del processo potrebbe richiedere alcuni minuti, a seconda delle dimensioni dell'applicazione.

1. Espandi l'area di lavoro per visualizzare i file e le cartelle che hai aggiunto all'area di lavoro. **I tipi di oggetti e i report sulla complessità ciclomatica sono visibili anche nel quadrante superiore del riquadro Chart Viewer.**

È ora possibile utilizzare Enterprise Analyzer per tutte le attività necessarie.

## Sessioni successive
<a name="tutorial-ea-step4"></a>

1. Avvia una sessione con WorkSpaces Applications con l'URL che hai ricevuto nel messaggio e-mail di benvenuto inviato da WorkSpaces Applications.

1. Accedi con la tua e-mail e la password permanente.

1. Seleziona lo stack Enterprise Analyzer.

1. Avvia `Rclone` per connetterti al disco supportato da Amazon S3 se utilizzi questa opzione per condividere i file dell'area di lavoro.

1. Avvia Enterprise Analyzer per svolgere le tue attività.

## Risoluzione dei problemi di connessione all'area di lavoro
<a name="tutorial-ea-step5"></a>

Quando si tenta di riconnettersi all'area di lavoro di Enterprise Analyzer, è possibile che venga visualizzato un errore simile al seguente:

```
Cannot access the workspace directory D:\PhotonUser\My Files\Home Folder\EA_BankDemo. The workspace has been created on a non-shared disk of the EC2AMAZ-E6LC33H computer. Would you like to correct the workspace directory location?
```

Per risolvere questo problema, scegli **OK** per cancellare il messaggio, quindi completa i seguenti passaggi.

1. In WorkSpaces Applicazioni, scegliete l'icona **Avvia applicazione** sulla barra degli strumenti, quindi scegliete **EA\$1Admin per avviare lo strumento di amministrazione** di Enterprise Analyzer.  
![\[Il menu di selezione dell'avvio WorkSpaces delle applicazioni con lo strumento di amministrazione Rocket Enterprise Developer selezionato.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/aas-launch-selector.png)

1. Dal menu **Amministra**, scegli **Aggiorna** percorso dell'area di lavoro... .  
![\[Amministra il menu dello strumento di amministrazione Rocket Enterprise Analyzer con l'opzione Refresh Workspace Path selezionata.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ea_admin-administer-refresh.png)

1. **In **Seleziona area di lavoro, scegli l'area** di lavoro che desideri, quindi scegli OK.**  
![\[La finestra di dialogo Seleziona l'area di lavoro dello strumento di amministrazione Rocket Enterprise Analyzer con un progetto selezionato.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ea_admin-select-workspace.png)

1. Scegli **OK** per confermare il messaggio di errore.  
![\[Il messaggio di errore di Enterprise Analyzer «Cannot access the workspace directory» con OK selezionato.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ea_admin-select-workspace-error.png)

1. In **Workspace Directory network path**, inserite il percorso corretto del workspace, ad esempio. `D:\PhotonUser\My Files\Home Folder\EA\MyWorkspace3`  
![\[La finestra di dialogo Enterprise Analyzer Percorso di rete della directory di Workspace con un percorso di esempio.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ea_admin-workspace-directory-network-path.png)

1. Chiudete lo strumento di amministrazione di Micro Focus Enterprise Analyzer.  
![\[Lo strumento di amministrazione Micro Focus Enterprise Analyzer con il pulsante Chiudi selezionato.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/ea_admin-close.png)

1. In WorkSpaces Applicazioni, scegliete l'icona **Avvia applicazione** sulla barra degli strumenti, quindi scegliete **EA** per avviare Micro Focus Enterprise Analyzer.  
![\[L'icona WorkSpaces Applicazioni avvia l'applicazione con EA selezionato.\]](http://docs.aws.amazon.com/it_it/m2/latest/userguide/images/aas-launch-ea.png)

1. Ripetere i passaggi da 3 a 5.

Micro Focus Enterprise Analyzer dovrebbe ora aprirsi con l'area di lavoro esistente.

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

Se non avete più bisogno delle risorse che avete creato per questo tutorial, eliminatele in modo da non incorrere in ulteriori addebiti. Completa questa procedura:
+ Utilizzate lo strumento **EA\$1Admin per eliminare l'**area di lavoro.
+ 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 S3*.
+ Elimina il database che hai creato per questo tutorial. Per ulteriori informazioni, consulta la sezione relativa all'[eliminazione di un'istanza database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.PostgreSQL.html#CHAP_GettingStarted.Deleting.PostgreSQL).

# Tutorial: configurare Rocket Enterprise Developer sulle applicazioni WorkSpaces
<a name="set-up-ed"></a>

Questo tutorial descrive come configurare Rocket Enterprise Developer (precedentemente Micro Focus Enterprise Developer) per una o più applicazioni mainframe al fine di gestirle, compilarle e testarle utilizzando le funzionalità di Enterprise Developer. La configurazione si basa sulle immagini Windows delle WorkSpaces applicazioni che AWS Mainframe Modernization condivide con il cliente e sulla creazione di flotte e stack di WorkSpaces applicazioni come descritto in. [Tutorial: Configurazione WorkSpaces delle applicazioni da utilizzare con Rocket Enterprise Analyzer e Rocket Enterprise Developer](set-up-appstream-mf.md)

**Importante**  
[I passaggi di questo tutorial presuppongono la configurazione WorkSpaces delle applicazioni utilizzando il modello scaricabile cfn-m2- .yaml CloudFormation . appstream-fleet-ea-ed](https://d1vi4vxke6c2hu.cloudfront.net/tutorial/cfn-m2-appstream-fleet-ea-ed.yaml) Per ulteriori informazioni, consulta [Tutorial: Configurazione WorkSpaces delle applicazioni da utilizzare con Rocket Enterprise Analyzer e Rocket Enterprise Developer](set-up-appstream-mf.md).  
È necessario eseguire i passaggi di questa configurazione quando la flotta e lo stack di Enterprise Developer sono attivi e funzionanti.

Per una descrizione completa delle funzionalità e dei risultati di Enterprise Developer v7, consultate la [documentazione up-to-date online (v7.0) sul sito Rocket Software (precedentemente Micro Focus)](https://www.microfocus.com/documentation/enterprise-developer/ed70/ED-Eclipse/GUID-8D6B7358-AC35-4DAF-A445-607D8D97EBB2.html).

## Contenuto dell'immagine
<a name="set-up-ed-image-contents"></a>

Oltre allo stesso Enterprise Developer, l'immagine contiene l'immagine contenente Rumba (un TN3270 emulatore). Contiene anche i seguenti strumenti e librerie.

Strumenti di terze parti
+ [Python](https://www.python.org/)
+ [Rclone](https://rclone.org/)
+ [pgAdmin](https://www.pgadmin.org/)
+ [gitscm](https://git-scm.com/)
+ [Driver ODBC PostgreSQL](https://odbc.postgresql.org/)

Librerie in `C:\Users\Public`
+ BankDemo codice sorgente e definizione del progetto per Enterprise Developer:`m2-bankdemo-template.zip`.
+ Pacchetto di installazione MFA per il mainframe:. `mfa.zip` Per ulteriori informazioni, vedere [Mainframe Access Overview](https://www.microfocus.com/documentation/enterprise-developer/30pu12/ED-VS2012/BKMMMMINTRS001.html) nella documentazione di *Micro Focus Enterprise* Developer.
+ File di comando e configurazione per Rclone (istruzioni per il loro utilizzo nei tutorial): e. `m2-rclone.cmd` `m2-rclone.conf`

Se devi accedere al codice sorgente che non è ancora stato caricato nei CodeCommit repository, ma che è disponibile in un bucket Amazon S3, ad esempio per eseguire il caricamento iniziale del codice sorgente in git, segui la procedura per creare un disco Windows virtuale come descritto in. [Tutorial: configurare Enterprise Analyzer sulle applicazioni WorkSpaces](set-up-ea.md)

**Topics**
+ [Contenuto dell'immagine](#set-up-ed-image-contents)
+ [Prerequisiti](#tutorial-ed-prerequisites)
+ [Fase 1: Configurazione da parte dei singoli utenti Enterprise Developer](#tutorial-ed-step1)
+ [Fase 2: creare la cartella virtuale basata su Amazon S3 su Windows (opzionale)](#tutorial-ed-step2)
+ [Passaggio 3: clonare il repository](#tutorial-ed-step3)
+ [Sessioni successive](#tutorial-ed-step4)
+ [Eseguire la pulizia delle risorse](#tutorial-ed-clean)

## Prerequisiti
<a name="tutorial-ed-prerequisites"></a>
+ Uno o più CodeCommit repository caricati con il codice sorgente dell'applicazione da gestire. La configurazione del repository deve soddisfare i requisiti della CI/CD pipeline di cui sopra per creare sinergie combinando entrambi gli strumenti.
+ Ogni utente deve disporre delle credenziali per il CodeCommit repository o i repository definiti dall'amministratore dell'account in base alle informazioni in [Authentication and access control for AWS](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control.html). CodeCommit La struttura di tali credenziali è esaminata in [Authentication and access control for AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control.html) e il riferimento completo per le autorizzazioni IAM CodeCommit si trova nel [riferimento alle CodeCommit autorizzazioni](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-permissions-reference.html): l'amministratore può definire politiche IAM distinte per ruoli distinti con credenziali specifiche per il ruolo di ciascun repository e limitando le autorizzazioni dell'utente allo specifico set di attività che deve svolgere su un determinato repository. Pertanto, per ogni manutentore del CodeCommit repository, l'amministratore dell'account genererà un utente principale e concederà a tale utente le autorizzazioni per accedere al repository o ai repository richiesti selezionando la politica o le politiche IAM appropriate per CodeCommit l'accesso.

## Fase 1: Configurazione da parte dei singoli utenti Enterprise Developer
<a name="tutorial-ed-step1"></a>

1. Ottieni le tue credenziali IAM:

   1. Connect alla AWS console all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

   1. Segui la procedura descritta nel passaggio 3 di [Configurazione per gli utenti HTTPS che utilizzano le credenziali Git](https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-gc.html) nella *Guida per l'AWS CodeCommit utente*. 

   1. Copia le credenziali di accesso CodeCommit specifiche che IAM ha generato per te, mostrando, copiando e incollando queste informazioni in un file sicuro sul tuo computer locale oppure scegliendo **Scarica credenziali per scaricare** queste informazioni come file.CSV. Queste informazioni sono necessarie per connettersi a CodeCommit.

1. Avvia una sessione con WorkSpaces Applications in base all'URL ricevuto nell'e-mail di benvenuto. Usa la tua email come nome utente e crea la tua password.

1. Seleziona il tuo stack Enterprise Developer.

1. Nella pagina del menu, scegli **Desktop** per accedere al desktop di Windows trasmesso in streaming dalla flotta.

## Fase 2: creare la cartella virtuale basata su Amazon S3 su Windows (opzionale)
<a name="tutorial-ed-step2"></a>

Se è necessario Rclone (vedi sopra), crea la cartella virtuale basata su Amazon S3 su Windows: (opzionale se tutti gli artefatti dell'applicazione provengono esclusivamente da Access). CodeCommit 

**Nota**  
Se hai già utilizzato Rclone durante l'anteprima di AWS Mainframe Modernization, devi eseguire l'aggiornamento alla versione più recente disponibile in. `m2-rclone.cmd` `C:\Users\Public`

1. Copia i `m2-rclone.cmd` file `m2-rclone.conf` and forniti nella tua cartella home usando File `C:\Users\Public` Explorer. `C:\Users\PhotonUser\My Files\Home Folder`

1. Aggiorna i parametri di `m2-rclone.conf` configurazione con la tua chiave di AWS accesso e il segreto corrispondente, oltre al tuo Regione AWS.

   ```
   [m2-s3]
   type = s3
   provider = AWS
   access_key_id = YOUR-ACCESS-KEY
   secret_access_key = YOUR-SECRET-KEY
   region = YOUR-REGION
   acl = private
   server_side_encryption = AES256
   ```

1. In `m2-rclone.cmd`, apporta le seguenti modifiche:
   + Cambia `amzn-s3-demo-bucket` il nome del tuo bucket Amazon S3. Ad esempio, `m2-s3-mybucket`.
   + Passa `your-s3-folder-key` alla tua bucket key Amazon S3. Ad esempio, `myProject`.
   + Passa `your-local-folder-path` al percorso della directory in cui desideri sincronizzare i file dell'applicazione dal bucket Amazon S3 che li contiene. Ad esempio, `D:\PhotonUser\My Files\Home Folder\m2-new`. Questa directory sincronizzata deve essere una sottodirectory della cartella Home per consentire alle WorkSpaces applicazioni di eseguire correttamente il backup e il ripristino all'inizio e alla fine della sessione.

   ```
   :loop
   timeout /T 10
   "C:\Program Files\rclone\rclone.exe" sync m2-s3:amzn-s3-demo-bucket/your-s3-folder-key "D:\PhotonUser\My Files\Home Folder\your-local-folder-path" --config "D:\PhotonUser\My Files\Home Folder\m2-rclone.conf"
   goto :loop
   ```

1. Apri un prompt dei comandi di Windows, cd to `C:\Users\PhotonUser\My Files\Home Folder` se necessario ed esegui. `m2-rclone.cmd` Questo script di comandi esegue un ciclo continuo, sincronizzando il bucket e la chiave Amazon S3 con la cartella locale ogni 10 secondi. Puoi regolare il timeout in base alle tue esigenze. Dovresti vedere il codice sorgente dell'applicazione che si trova nel bucket Amazon S3 in Windows File Explorer.

Per aggiungere nuovi file al set su cui stai lavorando o aggiornare quelli esistenti, carica i file nel bucket Amazon S3 e verranno sincronizzati con la tua directory alla successiva iterazione definita in. `m2-rclone.cmd` Allo stesso modo, se desideri eliminare alcuni file, eliminali dal bucket Amazon S3. La prossima operazione di sincronizzazione li eliminerà dalla directory locale.

## Passaggio 3: clonare il repository
<a name="tutorial-ed-step3"></a>

1. Vai al menu di selezione dell'applicazione nell'angolo in alto a sinistra della finestra del browser e seleziona Enterprise Developer.

1. Completa la creazione dell'area di lavoro richiesta da Enterprise Developer nella cartella Home scegliendo `C:\Users\PhotonUser\My Files\Home Folder` (alias`D: \PhotonUser\My Files\Home Folder`) come posizione per l'area di lavoro.

1. In Enterprise Developer, clona il tuo CodeCommit repository andando su Project Explorer, fai clic con il pulsante destro del mouse e scegli **Importa, Importa****...**, **Git**, **Progetti dall'URI** **Git** **Clone**. Quindi, inserisci le tue credenziali CodeCommit di accesso specifiche e completa la finestra di dialogo Eclipse per importare il codice.

Il repository CodeCommit git è ora clonato nel tuo spazio di lavoro locale.

L'area di lavoro di Enterprise Developer è ora pronta per iniziare i lavori di manutenzione dell'applicazione. In particolare, è possibile utilizzare l'istanza locale di Enterprise Server (ES) integrata con Enterprise Developer per eseguire il debug in modo interattivo ed eseguire l'applicazione per convalidare le modifiche a livello locale.

**Nota**  
L'ambiente Enterprise Developer locale, inclusa l'istanza locale di Enterprise Server, viene eseguito su Windows mentre AWS Mainframe Modernization viene eseguito su Linux. Si consiglia di eseguire test complementari nell'ambiente Linux fornito da AWS Mainframe Modernization dopo aver eseguito il commit della nuova applicazione CodeCommit e averla ricostruita per questo obiettivo e prima di implementarla in produzione.

## Sessioni successive
<a name="tutorial-ed-step4"></a>

Quando selezioni una cartella in Gestione delle WorkSpaces applicazioni, ad esempio la cartella home per la clonazione del tuo CodeCommit repository, questa verrà salvata e ripristinata in modo trasparente tra le sessioni. La prossima volta che utilizzerai l'applicazione, completa i seguenti passaggi: 

1. Avvia una sessione con WorkSpaces Applications in base all'URL ricevuto nell'e-mail di benvenuto.

1. Accedi con la tua email e la password permanente.

1. Seleziona lo stack Enterprise Developer.

1. Avvia `Rclone` per connetterti (vedi sopra) al disco supportato da Amazon S3 quando questa opzione viene utilizzata per condividere i file dell'area di lavoro.

1. Avvia Enterprise Developer per fare il tuo lavoro.

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

Se non ti servono più le risorse che hai creato per questo tutorial, eliminale in modo da non continuare a ricevere costi aggiuntivi. Completa questa procedura:
+ Elimina l' CodeCommit archivio che hai creato per questo tutorial. Per ulteriori informazioni, consulta [Eliminare un CodeCommit repository nella Guida](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html) per l'*AWS CodeCommit utente*.
+ Elimina il database che hai creato per questo tutorial. Per ulteriori informazioni, consulta la sezione relativa all'[eliminazione di un'istanza database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.PostgreSQL.html#CHAP_GettingStarted.Deleting.PostgreSQL).