AWS Le service de modernisation du mainframe (expérience de l'environnement d'exécution géré) n'est plus ouvert aux nouveaux clients. Pour des fonctionnalités similaires au service de modernisation AWS du mainframe (expérience de l'environnement d'exécution géré), explorez le service de modernisation AWS du mainframe (expérience autogérée). Les clients existants peuvent continuer à utiliser le service normalement. Pour plus d'informations, consultez la section [Modification de la disponibilité de la modernisation du AWS mainframe](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# AWS Mainframe Modernization Conversion de code avec mLogica
AWS Mainframe Modernization La conversion de code avec MLogica (conversion de code) est une AWS Mainframe Modernization fonctionnalité qui convertit automatiquement le code de l'assembleur du z/OS mainframe en COBOL. Vous pouvez utiliser la conversion de code pour extraire une image d'assembleur à l'aide du AWS CodeBuild service pour la conversion de code que vous souhaitez effectuer avec votre Compte AWS.
**Topics**
+ [Qu'est-ce que la conversion en assembleur avec mLogica ?](assembler-conversion-what-is.md)
+ [Comprendre la facturation de la conversion de code pour la conversion d'un assembleur](assembler-conversion-billing.md)
+ [Concepts de conversion de code](assembler-conversion-concepts.md)
+ [Comprendre les composants et les processus de conversion de code](assembler-conversion-components-process.md)
+ [Tutoriel : Convertir le code d'Assembler en COBOL dans AWS Mainframe Modernization](assembler-conversion-steps.md)
# Qu'est-ce que la conversion en assembleur avec mLogica ?
AWS Mainframe Modernization La conversion de code avec MLogica (conversion de code) convertit automatiquement le code de l'assembleur du z/OS mainframe en COBOL. Le service s'exécute dans votre environnement Compte AWS et ne transmet ni ne stocke le code source Assembler ou COBOL en dehors du Compte AWS. La conversion de code permet à votre compte autorisé d'extraire une image d'assembleur à l'aide du AWS CodeBuild service pour la conversion de code souhaitée.
AWS Mainframe Modernization vous permet de configurer des builds et des pipelines de integration/continuous livraison continue (CI/CD) pour vos applications migrées. Ces builds et pipelines utilisent AWS CodeBuild Amazon S3 pour fournir cette fonctionnalité. AWS CodeBuild est un service de génération entièrement géré qui compile votre code source, exécute des tests unitaires et produit des artefacts prêts à être déployés. Amazon S3 est un service de stockage d'objets qui offre une évolutivité, une disponibilité des données, une sécurité et des performances de pointe.
**Contents**
+ [Compilateurs de conversion de code](#assembler-conversion-compilers)
+ [Architecture de conversion de code](#assembler-conversion-architecture)
+ [Approche d'automatisation](#assembler-conversion-automation)
+ [Sécurité](#assembler-conversion-security)
+ [Ressources supplémentaires](#assembler-conversion-additional-resources)
## Compilateurs de conversion de code
La conversion de code peut être configurée pour émettre du COBOL adapté à la compilation et à l'exécution dans plusieurs environnements cibles avec différents compilateurs. Certains d'entre eux incluent :
+ M2 Replateforme avec Rocket Software (anciennement Micro Focus) et d'autres environnements Rocket Enterprise Server
+ Reconfiguration de la plateforme M2 avec NTT DATA Enterprise COBOL () UniKix
+ MLogica LIBER\$1COBOL
+ z/OSMainframe utilisant IBM Enterprise COBOL
+ Iscobol Veryant
## Architecture de conversion de code
Voici un schéma architectural du processus de conversion du code :
![\[Schéma architectural du processus de conversion du code.\]](http://docs.aws.amazon.com/fr_fr/m2/latest/userguide/images/conversion-architecture.png)
## Approche d'automatisation
Pour utiliser la conversion de code avec CodeBuild, le code Assembler doit être chargé dans un compartiment Amazon S3, afin de configurer ultérieurement les paramètres de conversion et d'invoquer un CodeBuild projet pour effectuer chaque étape du processus de conversion. Le code COBOL cible est automatiquement stocké dans un chemin spécifié dans le compartiment Amazon S3.
## Sécurité
AWS Mainframe Modernization La conversion de code permet la conversion tout en conservant tout le code source et cible dans votre Compte AWS. Le code source de l'assembleur, le code COBOL cible et les fichiers de configuration sont stockés dans votre compartiment Amazon S3. L'outil de conversion automatique fonctionne comme un conteneur dans l' CodeBuild environnement de votre Compte AWS. Le code reste dans votre compte à tout moment.
Pour permettre à l'outil de conversion d'accéder à votre compartiment Amazon S3, vous accordez des autorisations au compartiment à un Service AWS rôle. Lors de la configuration CodeBuild, vous définissez ce rôle de service afin de CodeBuild pouvoir accéder à l'image du conteneur et à votre compartiment Amazon S3.
## Ressources supplémentaires
En plus de cela[Tutoriel : Convertir le code d'Assembler en COBOL dans AWS Mainframe Modernization](assembler-conversion-steps.md), voici quelques ressources supplémentaires où vous pouvez en savoir plus sur la création des CloudFormation modèles et d'autres informations sur la conversion d'Assembler en COBOL.
+ Lien vers l'atelier pour la conversion automatique du code d'Assembler en COBOL :[https://catalog.workshops.aws/awsm2ccm-assembler-cobol/en-US](https://catalog.workshops.aws/awsm2ccm-assembler-cobol/en-US).
+ Article de blog :[https://aws.amazon.com/blogs/migration-and-modernization/unlocking-new-potential-transform-your-assembler-programs-to-cobol-with-aws-mainframe-modernization/](https://aws.amazon.com/blogs/migration-and-modernization/unlocking-new-potential-transform-your-assembler-programs-to-cobol-with-aws-mainframe-modernization/).
# Comprendre la facturation de la conversion de code pour la conversion d'un assembleur
Vous allez consulter cette page pour comprendre le champ d'application et le processus de facturation liés à la conversion du code avant de procéder à la conversion proprement dite. La section de calcul de la facturation mentionne le processus par lequel la conversion d'Assembler en COBOL est facturée pour chaque ligne de code.
## Conversion de code, facturation et champ d'application
La conversion du code assembleur génère des frais (rapports de facturation) Compte AWS uniquement après avoir terminé l'étape *de conversion*. Les frais sont basés sur le nombre de lignes de code converties. Si vous effectuez plusieurs étapes de conversion, par exemple après avoir ajouté un nouveau code Assembler, modifié la configuration de conversion ou appliqué une nouvelle version du conteneur, seules les lignes modifiées et/ou les lignes nouvellement ajoutées sont utilisées pour calculer les frais. Nous ne vous facturerons pas deux fois pour la conversion de la même ligne de code dans le même programme.
**Note**
Les modules dont les lignes de code ont été modifiées et toutes les lignes de code des programmes nouveaux ou renommés seront facturés.
Pour éviter plusieurs frais, la conversion de code stocke un fichier binaire codé pour chaque module Assembler ou Macro dans le compartiment du projet dans`/awsm2ccm-do-not-delete//Hash`. Ces fichiers codés ne contiennent aucun code client.
**Important**
Ne modifiez ou ne supprimez pas ces fichiers manuellement. Les modifications peuvent entraîner plusieurs facturations pour la conversion des mêmes composants.
Le rapport d'analyse de la conversion du AWS Mainframe Modernization code (« Rapport d'analyse ») fournit aux clients des détails sur l'étendue de la conversion prévue, le résultat et la facturation afin de garantir des attentes précises quant à la conversion réelle. La conversion peut entraîner la non-conversion de certaines lignes de code, la conversion partielle de certaines lignes de code et la conversion complète de certaines lignes de code. Le rapport d'analyse indique le nombre de lignes de code pour chaque catégorie. **Vous devez exécuter et lire le rapport d'analyse avant de procéder à toute conversion de programmes, de macros et de cahiers.** Une fois qu'un client a lu le rapport d'analyse et qu'il est d'accord avec le champ d'application indiqué, le résultat attendu et la facturation attendue, il peut poursuivre l'exécution de la conversion.
**Note**
En exécutant la `Convert` commande de conversion du code de modernisation du mainframe AWS, vous reconnaissez avoir exécuté et lu le rapport d'analyse, et vous acceptez le résultat attendu et le nombre facturable de lignes de code.
### Étendue de la conversion
AWS Mainframe Modernization La conversion de code traite toutes les lignes de code de tous les composants assembleur, macro et copybook disponibles dans les répertoires *scrlib* et *macrolib* de l'emplacement source S3 configuré. Les programmes d'assemblage, ainsi que toutes les macros et tous les copybooks référencés dans un programme d'assemblage, sont *concernés.* Les composants de macro et de cahier qui ne sont pas référencés par un programme assembleur sont considérés comme *hors de portée* et ne sont pas convertis. Pendant le traitement, le convertisseur exécute des algorithmes avancés qui prennent en compte chaque composant du champ d'application de manière globale. Toutes les lignes de code de ces composants participent au traitement, qu'elles soient totalement, partiellement converties ou non converties. AWS Mainframe Modernization La conversion de code ignore les lignes vides et ne les considère pas comme des lignes de code. Les lignes de commentaires et les lignes contenant tout autre texte (par exemple, les instructions JCL pour l'assembleur intégré à JCL) sont considérées comme des lignes de code pour la facturation.
### Calcul de facturation
AWS Mainframe Modernization Frais de conversion de code pour l'ensemble des composants concernés. Cela signifie qu'il facture chaque ligne de code de chaque composant concerné, y compris les lignes qui n'ont pas pu être converties, qui ont été partiellement converties et qui ont été totalement converties. AWS Mainframe Modernization La conversion de code additionne toutes les lignes de code des composants fournis pour le traitement (y compris les programmes d'assemblage, les cahiers référencés et les macros référencées) et utilise le nombre total de lignes de code pour la facturation.
**Note**
Les copybooks et les macros non référencés par un programme Assembler ne sont pas considérés comme concernés.
Supposons par exemple qu'un programme comporte 1 000 lignes de code :
+ 700 lignes sont entièrement converties
+ 200 lignes sont partiellement converties
+ 100 lignes ne sont pas converties
1 000 lignes de code seront traitées et seront facturables.
### Améliorer la conversion
Si, en tant que client, vous recherchez un taux de conversion plus élevé pour les lignes de code ou si vous avez d'autres exigences spécifiques, vous pouvez contacter les AWS représentants pour obtenir des options d'engagement supplémentaires, telles qu'un effort de calibrage ou une assistance de services professionnels.
# Concepts de conversion de code
Pour savoir comment se produit la conversion de code, il CodeBuild est important de comprendre certains concepts clés tels que la gestion des macros, les pages de code, etc.
**Topics**
+ [Gestion des macros](#conversion-concepts-macro-handling)
+ [Pages de codes (EBCDIC ou ASCII)](#conversion-concepts-code-pages)
+ [CodeBuild](#conversion-concepts-code-build)
## Gestion des macros
Le code Mainframe Assembler utilise fréquemment des macros pour encapsuler les fonctionnalités en vue de leur réutilisation. Le comportement des macros est généralement déterminé lors de l'exécution de l'application en fonction des paramètres transmis par un programme Assembler. La conversion de code fournit plusieurs mécanismes pour étendre les macros d'assemblage avant la conversion en COBOL.
## Pages de codes (EBCDIC ou ASCII)
Mainframe Assembler contient souvent des littéraux de caractères exprimés sous forme de valeurs hexadécimales correspondant aux caractères EBCDIC. La conversion de code fournit une fonctionnalité configurable permettant de gérer automatiquement les littéraux de caractères en ASCII lors de l'émission de COBOL pour les environnements ASCII.
## CodeBuild
La conversion de code est disponible via le AWS CodeBuild service. AWS CodeBuild est un outil d'automatisation de construction conçu à l'origine dans le cadre d'un CI/CD pipeline. In AWS Mainframe Modernization, AWS CodeBuild est utilisé pour automatiser l'outil de conversion MCCAC et d'autres outils tels que le compilateur COBOL Rocket Software (anciennement Micro Focus).
# Comprendre les composants et les processus de conversion de code
AWS Mainframe Modernization Le processus de conversion de code inclut divers composants tels que le AWS Mainframe Modernization conteneur, le compartiment de projet S3 et l'emplacement des fichiers journaux.
**Topics**
+ [AWS Mainframe Modernization contenant](#assembler-conversion-components-container)
+ [compartiment de projet S3](#assembler-conversion-components-s3)
+ [Emplacement des fichiers journaux](#assembler-conversion-components-log)
+ [Présentation du processus](#assembler-conversion-process)
## AWS Mainframe Modernization contenant
AWS Mainframe Modernization Le conteneur de conversion de code s'exécute dans le AWS CodeBuild projet et fournit des commandes pour configurer les répertoires du projet et les fichiers de configuration, évaluer le code Assembler, développer les macros Assembler et convertir le code Assembler en COBOL.
Vous aurez accès au référentiel AWS ECR suivant :`381492161314.dkr.ecr.us-east-1.amazonaws.com/aws-mlogica-codebuild-prod`.
Pour utiliser les images, vous pouvez suivre l'une des deux options suivantes :
+ Utilisez la dernière balise lorsque vous consommez l'image via AWS CodeBuild. Lorsque vous utilisez l'image, vous utiliserez ce chemin :`381492161314.dkr.ecr.us-east-1.amazonaws.com/aws-mlogica-codebuild-prod`. Cela signifie que cela AWS CodeBuild récupérera la dernière image envoyée dans le référentiel.
+ Lister la version et sélectionner parmi celles-ci. Pour ce faire, utilisez la commande suivante via la CLI pour répertorier les différentes versions du référentiel :
```
aws ecr describe-images \
--registry-id 381492161314 \
--repository-name aws-mlogica-codebuild-prod \
--query 'imageDetails[*].{ImagePushedAt: imagePushedAt, ImageTags: imageTags}' \
--output json | jq '[.[] | {ImageURI: (.ImageTags[] | "381492161314.dkr.ecr.us-east-1.amazonaws.com/aws-mlogica-codebuild-prod:" + .), ImagePushedAt: .ImagePushedAt}] | sort_by(.ImagePushedAt) | reverse'
```
Cela listera toutes les images avec le tag associé sur chaque image, ainsi que l'heure à laquelle une image particulière a été publiée dans le référentiel. Sur la base du code ci-dessus, vous obtiendrez une liste d'images où la balise sur l'image représente la version de l'utilitaire de conversion de code. Vous pouvez sélectionner l'image appropriée en fonction de vos besoins.
## compartiment de projet S3
Le code d'entrée et de sortie, le code mis à jour avec des macros étendues et les rapports générés par la conversion de AWS Mainframe Modernization code sont stockés dans le bucket de projet que vous créez dans votre Gestion de compte AWS. Vous AWS Mainframe Modernization permettez à Code Conversion d'accéder au bucket en accordant des autorisations à un rôle AWS de service.
## Emplacement des fichiers journaux
Les fichiers journaux sont écrits à deux endroits lors de l'exécution de chaque CodeBuild projet :
+ Les fichiers journaux contenant les résultats de haut niveau de chaque CodeBuild étape sont écrits dans les fichiers journaux du compartiment de journalisation configuré dans le CodeBuild. Ces fichiers apparaissent sous forme d'archives gzip avec un nom de fichier de type GUID généré par le CodeBuild framework (par exemple,`0c03e183-ab40-4fe0-ba77- bc1d87e73b14.gz`). Chaque archive contient le journal généré par l'exécution d'un CodeBuild projet. Si l'exécution d'un CodeBuild projet échoue, ce fichier journal contiendra des informations de dépannage importantes.
+ Les fichiers journaux contenant les résultats d'exécution détaillés au niveau du composant sont écrits dans les fichiers journaux situés dans le chemin du compartiment principal du projet avec le modèle de nom de fichier `_.log` (par exemple`project- bucket_202406131200.log`). Ces journaux fournissent :
+ Un résumé de configuration indiquant les emplacements d'entrée et de sortie.
+ Un journal de chaque composant Assembler ou Macro traité avec le nom de fichier cible.
+ Liste des rapports générés avec l'emplacement des fichiers.
+ Pour les exécutions de conversion, liste des cahiers d'exécution fournis.
## Présentation du processus
Le schéma suivant illustre le processus de conversion d'Assembler en COBOL :
![\[Comment fonctionne la conversion de code d'Assembler en COBOL.\]](http://docs.aws.amazon.com/fr_fr/m2/latest/userguide/images/conversion-process-overview.png)
# Tutoriel : Convertir le code d'Assembler en COBOL dans AWS Mainframe Modernization
Vous pouvez utiliser ce document comme step-by-step guide pour comprendre comment convertir le code Assembler de modernisation du mainframe en COBOL. En outre, vous pouvez également consulter l'[atelier sur la conversion automatique de code d'Assembler en COBOL](https://catalog.workshops.aws/awsm2ccm-assembler-cobol/en-US) pour en savoir plus sur le processus de conversion.
**Contents**
+ [Conditions préalables](#tutorial-assembler-conversion-prerequisites)
+ [Étape 1 : Partagez les actifs de construction avec Compte AWS](#tutorial-assembler-conversion-share-assets)
+ [Étape 2 : créer des compartiments Amazon S3](#tutorial-assembler-conversion-create-bucket)
+ [Étape 3 : Création d'une politique IAM](#tutorial-assembler-conversion-IAM-policy)
+ [Étape 4 : Création d'un rôle IAM](#tutorial-assembler-conversion-IAM-role)
+ [Étape 5 : associer la politique IAM au rôle IAM](#tutorial-assembler-conversion-attach)
+ [Étape 6 : Création du CodeBuild projet](#tutorial-assembler-conversion-create-project)
+ [Étape 6.1 : Création du projet Define](#tutorial-conversion-define-project)
+ [Étape 6.2 : Création du projet d'analyse de code](#tutorial-conversion-analysis-project)
+ [Étape 6.3 : Création du projet de conversion de code](#tutorial-conversion-code-project)
+ [Étape 7 : Définition du projet et téléchargement du code source](#tutorial-assembler-conversion-define-upload)
+ [Étape 8 : Exécuter l'analyse et comprendre les rapports](#tutorial-assembler-conversion-run-analysis)
+ [Étape 9 : Exécuter la conversion du code](#tutorial-assembler-conversion-run-code)
+ [Étape 10 : Vérifiez la conversion du code](#tutorial-assembler-conversion-verify)
+ [Étape 11 : Téléchargez le code converti](#tutorial-assembler-conversion-download)
+ [nettoyer des ressources ;](#tutorial-assembler-conversion-clean-resources)
## Conditions préalables
Lisez la [Comprendre la facturation de la conversion de code pour la conversion d'un assembleur](assembler-conversion-billing.md) section pour comprendre comment la conversion du code Assembler génère des frais (rapports de facturation) sur votre Gestion de compte AWS compte et comment fonctionne la facturation.
## Étape 1 : Partagez les actifs de construction avec Compte AWS
Au cours de cette étape, assurez-vous de partager les actifs de construction avec vous Compte AWS, en particulier dans la région où les actifs sont utilisés.
1. Ouvrez la AWS Mainframe Modernization console à l'adresse [https://console.aws.amazon.com/m2/](https://us-west-2.console.aws.amazon.com/m2/home?region=us-west-2#/).
1. Dans le volet de navigation de gauche, sélectionnez **Outils**.
1. Dans **Conversion du code de modernisation du mainframe AWS avec mLogica**, choisissez **Share assets** with my. Compte AWS
**Important**
Vous devez effectuer cette étape une fois dans chaque AWS région où vous avez l'intention d'effectuer des builds.
## Étape 2 : créer des compartiments Amazon S3
Au cours de cette étape, vous créez des compartiments Amazon S3. Le premier compartiment est le compartiment de projet destiné AWS CodeBuild à contenir le code source, puis à pousser le compartiment de sortie pour contenir la AWS CodeBuild sortie (code converti). Pour plus d'informations, consultez [la section Création, configuration et utilisation des compartiments Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html) dans le *guide de l'utilisateur Amazon S3*.
1. Pour créer le compartiment de projet, connectez-vous à la console Amazon S3 et choisissez **Create bucket**.
1. Dans **Configuration générale**, donnez un nom au compartiment et spécifiez l' Région AWS endroit où vous souhaitez le créer. Un exemple de nom est`codebuild-regionId-accountId-bucket`, où :
+ `regionId`est le Région AWS produit du seau.
+ `accountId`est votre Compte AWS identifiant.
**Note**
Si vous créez le bucket dans un pays différent Région AWS de celui de l'est des États-Unis (Virginie du Nord), spécifiez le `LocationConstraint` paramètre. Pour plus d'informations, consultez [Create Bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html) dans le manuel *Amazon Simple Storage Service API Reference*.
1. Conservez tous les autres paramètres, puis choisissez **Create bucket**.
Quels que soient les noms que vous choisissez pour ces compartiments, veillez à les utiliser tout au long de ce didacticiel.
## Étape 3 : Création d'une politique IAM
Au cours de cette étape, vous allez créer une [politique IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html). La politique IAM fournie accorde des autorisations spécifiques AWS CodeBuild pour interagir avec Amazon S3, Amazon Elastic Container Registry, les [ CloudWatch journaux Amazon qui les](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) CodeBuild génèrent et les Amazon Elastic Compute Cloud ressources pour la conversion de code. Cette politique n'est pas personnalisée pour les clients. La politique accorde des autorisations AWS Mainframe Modernization pour interagir et récupérer les statistiques de conversion du code afin de facturer le client de manière appropriée.
Pour en savoir plus sur la création d'une stratégie IAM, consultez la section [Création de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) dans le guide de l'utilisateur *IAM*.
**Pour créer une politique**
1. Connectez-vous à la console IAM, puis sélectionnez **Policies** dans le volet de navigation de gauche.
1. Choisissez **Create Policy** (Créer une politique).
1. Copiez et collez la politique JSON suivante dans l'éditeur de politiques.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:GetBucketLocation",
"s3:ListBucket",
"s3:PutObjectAcl",
"s3:GetBucketAcl"
],
"Resource": [
"arn:aws:s3:::codebuild-regionId-accountId-bucket",
"arn:aws:s3:::codebuild-regionId-accountId-bucket/*",
"arn:aws:s3:::aws-m2-repo-*" ],
"Effect": "Allow"
},
{
"Action": [
"ecr:GetAuthorizationToken",
"ecr:BatchCheckLayerAvailability",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer",
"logs:*",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeNetworkInterfaces",
"ec2:DeleteNetworkInterface",
"ec2:CreateNetworkInterface",
"ec2:DescribeDhcpOptions",
"ec2:DescribeVpcs",
"ec2:CreateNetworkInterfacePermission"
],
"Resource": "*",
"Effect": "Allow"
}
]
}
```
------
1. Vous pouvez éventuellement ajouter des balises à la politique. Les balises sont des paires clé-valeur qui peuvent vous aider à organiser, suivre ou contrôler l'accès à la politique.
1. Choisissez **Next: Review (Suivant : vérifier)**.
1. Donnez un nom à la politique, par exemple,`CodeBuildAWSM2CCMPolicy`.
1. Vous pouvez éventuellement saisir une description de la politique et consulter le résumé de la politique pour vous assurer qu'il est correct.
1. Choisissez **Create Policy** (Créer une politique).
## Étape 4 : Création d'un rôle IAM
Au cours de cette étape, vous créez un nouveau [rôle IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) qui permet d'interagir avec les AWS ressources CodeBuild à votre place, après avoir associé les politiques IAM que vous avez créées précédemment à ce nouveau rôle IAM.
Pour plus d'informations sur la création d'un rôle de service, consultez la section [Création d'un rôle pour déléguer des autorisations à un AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) dans le *guide de l'utilisateur IAM*.
1. Connectez-vous à la console IAM, puis sélectionnez **Rôles** dans le volet de navigation de gauche.
1. Choisissez **Créer un rôle**.
1. Sous **Type d'entité fiable**, choisissez le **service AWS**.
1. Sous **Cas d'utilisation pour d'autres services AWS **CodeBuild****, choisissez, puis choisissez **CodeBuild**à nouveau.
1. Choisissez **Suivant**.
1. Sur la page **Add permissions** (Ajouter des autorisations), sélectionnez **Next** (Suivant). Vous attribuez une politique au rôle ultérieurement.
1. Sous **Détails du rôle**, saisissez un nom pour le rôle, par exemple,`IAMRoleTaskExecutionRoleForCodeBuild`.
1. Sous **Sélectionner les entités de confiance**, vérifiez que le document de politique ressemble à ce qui suit :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "codebuild.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Choisissez **Créer un rôle**.
## Étape 5 : associer la politique IAM au rôle IAM
Au cours de cette étape, vous associez la politique IAM que vous avez créée précédemment au rôle `IAMRoleTaskExecutionRoleForCodeBuild` IAM.
1. Connectez-vous à la console IAM, puis sélectionnez **Rôles** dans le volet de navigation de gauche.
1. Dans **Rôles**, choisissez le rôle que vous avez créé précédemment, par exemple`IAMRoleTaskExecutionRoleForCodeBuild`.
1. Dans **Politiques d'autorisations**, choisissez **Ajouter des autorisations**, puis **Joindre des politiques**.
1. Dans **Autres politiques d'autorisation**, choisissez les politiques que vous avez créées précédemment, par exemple`CodeBuildAWSM2CCMPolicy`.
1. Choisissez **Attacher des politiques**.
## Étape 6 : Création du CodeBuild projet
Au cours de cette étape, vous créez trois CodeBuild projets différents sur la base du `buildspec.yml` fichier mentionné ci-dessus.
### Étape 6.1 : Création du projet Define
**Pour créer le projet Define**
1. Connectez-vous à la CodeBuild console et choisissez **Create build project**.
1. Dans la section **Configuration du projet**, saisissez un nom pour le projet, par exemple,`1-awsm2ccm-define-project`.
1. Dans la section **Source**, pour **Source provider**, laissez la sélection par défaut.
1. Dans la section **Environnement**, choisissez **Image personnalisée**.
1. Dans le champ **Type d'environnement**, sélectionnez **Linux**.
1. Sous **Registre d'images**, choisissez **Autre registre**.
1. Dans le champ **URL du registre externe**, suivez la [AWS Mainframe Modernization contenant](assembler-conversion-components-process.md#assembler-conversion-components-container) section.
1. Sous **Rôle de service**, choisissez **Rôle de service existant**, puis dans le champ **ARN du rôle**, choisissez le rôle de service que vous avez créé précédemment (par exemple,`IAMRoleTaskExecutionRoleForCodeBuild`).
1. Développez la section **Configuration supplémentaire**, procédez comme suit :
1. VPC : configurez si nécessaire en fonction de votre configuration.
1. Délai d'attente : réglé sur **60 minutes.**
1. **Délai d'attente : défini sur 480 minutes.**
1. Chiffrement : Choisissez les paramètres de chiffrement appropriés (la valeur par défaut est correcte).
1. Dans la section **Variables d'environnement**, ajoutez les éléments suivants un par un :
+ Nom : **PROJECT\$1BUCKET**. Valeur :`codebuild-regionId-accountId- bucket`. Type : texte **brut**
+ Nom : **PROJECT\$1DIR**. Valeur :`prj_codebuild_01`. Type : texte **brut**
+ Nom : **AWSM2CCM\$1ACTION**. Valeur :`define_project`. Type : texte **brut**
+ Nom : **AWSM2CCM\$1LOGGING\$1BUCKET**. Valeur :`s3:// codebuild-regionId-accountId-bucket`. Type : texte **brut**
1. Dans la section **Buildspec**, choisissez **Insérer des commandes de construction**, puis **Basculer vers** l'éditeur.
1. Remplacez les valeurs actuelles par les suivantes :
```
version: 0.2
phases:
build:
commands:
- . /app/awsm2ccm_prod/bin/setup_env.sh
- run_awsm2ccm.sh $PROJECT_DIR
artifacts:
files:
- '**/*'
discard-paths: no
base-directory: $PROJECT_DIR
```
où PROJECT\$1DIR sont des variables d'environnement disponibles dans. CodeBuild Pour plus d'informations, consultez la section [Variables d'environnement dans les environnements de génération](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html).
1. Dans la section **Artefacts**, procédez comme suit :
+ sous **Type**, choisissez **Amazon S3**, puis choisissez votre compartiment de sortie, par exemple,`codebuild-regionId-accountId-bucket`.
+ pour **Path**, laissez ce champ vide.
+ pour **Nom**, entrez`prj_codebuild_01`.
+ **pour l'**emballage d'Artifact**, sélectionnez Aucun.**
+ pour **Remplacer le nom de l'artefact**, décochez cette option.
+ pour **le chiffrement**, laissez les paramètres par défaut.
1. Pour la section **Logs**, procédez comme suit :
+ CloudWatch journaux : **Désactivé**
+ Journaux S3 : **activé**
+ Compartiment: `codebuild-regionId-account-bucket`
+ Chemin du journal : `CODEBUILD-LOGS`
1. Choisissez **Créer un projet de génération**.
### Étape 6.2 : Création du projet d'analyse de code
**Pour créer le projet d'analyse de code**
1. Connectez-vous à la CodeBuild console et choisissez **Create build project**.
1. Dans la section **Configuration du projet**, saisissez un nom pour le projet, par exemple,`2-awsm2ccm-analysis`.
1. Dans la section **Source**, pour **Source provider**, choisissez **Amazon S3**, puis choisissez le bucket d'entrée que vous avez créé précédemment (par exemple,`codebuild-regionId-accountId-bucket`).
1. Dans le champ **clé d'objet S3** **ou dossier S3**, entrez`prj_codebuild_01`.
1. Dans la section **Environnement**, choisissez **Image personnalisée**.
1. Dans le champ **Type d'environnement**, sélectionnez **Linux**.
1. Sous **Registre d'images**, choisissez **Autre registre**.
1. Dans le champ **URL du registre externe**, suivez la [AWS Mainframe Modernization contenant](assembler-conversion-components-process.md#assembler-conversion-components-container) section.
1. Sous **Rôle de service**, choisissez **Rôle de service existant**, puis dans le champ **ARN du rôle**, choisissez le rôle de service que vous avez créé précédemment (par exemple,`IAMRoleTaskExecutionRoleForCodeBuild`).
1. Développez la section **Configuration supplémentaire**, procédez comme suit :
1. VPC : configurez si nécessaire en fonction de votre configuration.
1. Délai d'attente : réglé sur **60 minutes.**
1. **Délai d'attente : défini sur 480 minutes.**
1. Chiffrement : Choisissez les paramètres de chiffrement appropriés (la valeur par défaut est correcte).
1. Dans la section **Variables d'environnement**, ajoutez les éléments suivants un par un :
+ Nom : **PROJECT\$1BUCKET**. Valeur :`codebuild-regionId-accountId-bucket`. Type : texte **brut**
+ Nom : **PROJECT\$1DIR**. Valeur :`prj_codebuild_01`. Type : texte **brut**
+ Nom : **AWSM2CCM\$1ACTION**. Valeur :`analysis`. Type : texte **brut**
+ Nom : **AWSM2CCM\$1LOGGING\$1BUCKET**. Valeur :`s3:// codebuild-regionId-accountId-bucket`. Type : texte **brut**
1. Dans la section **Buildspec**, choisissez **Insérer des commandes de construction**, puis **Basculer vers** l'éditeur.
1. Remplacez les valeurs actuelles par les suivantes :
```
version: 0.2
phases:
build:
commands:
- ln -s $CODEBUILD_SRC_DIR $PROJECT_DIR
- . /app/awsm2ccm_prod/bin/setup_env.sh
- run_awsm2ccm.sh $PROJECT_DIR
artifacts:
files:
- '*.log'
- '_Converted/*/*'
- '_Reports/*'
secondary-artifacts:
reports:
files:
- '_Reports/AWSM2CCM*'
discard-paths: no
base-directory: $PROJECT_DIR
```
où PROJECT\$1DIR sont des variables d'environnement disponibles dans. CodeBuild Pour plus d'informations, consultez la section [Variables d'environnement dans les environnements de génération](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html).
1. Dans la section **Artefacts**, procédez comme suit :
+ sous **Type**, choisissez **Amazon S3**, puis choisissez votre compartiment de sortie (par exemple,`codebuild-regionId-accountId-bucket`).
+ dans le **champ Path**, saisissez **ARTIFACTS**.
+ pour **Nom**, entrez`prj_codebuild_01`.
+ **pour l'**emballage d'Artifact**, sélectionnez Aucun.**
+ pour **Remplacer le nom de l'artefact**, décochez cette option.
+ pour **le chiffrement**, laissez les paramètres par défaut.
1. Pour la section **Logs**, procédez comme suit :
+ CloudWatch journaux : **Désactivé**
+ Journaux S3 : **activé**
+ Compartiment: `codebuild-regionId-account-bucket`
+ Chemin du journal : `CODEBUILD-LOGS`
1. Choisissez **Créer un projet de génération**.
### Étape 6.3 : Création du projet de conversion de code
**Pour créer le projet de conversion de code**
1. Connectez-vous à la CodeBuild console et choisissez **Create build project**.
1. Dans la section **Configuration du projet**, saisissez un nom pour le projet (par exemple,`3-awsm2ccm-convert`).
1. Dans la section **Source**, pour **Source provider**, choisissez **Amazon S3**, puis choisissez le bucket d'entrée que vous avez créé précédemment (par exemple,`codebuild-regionId-accountId-bucket`).
1. Dans le champ **clé d'objet S3** **ou dossier S3**, entrez`prj_codebuild_01`.
1. Dans la section **Environnement**, choisissez **Image personnalisée**.
1. Dans le champ **Type d'environnement**, sélectionnez **Linux**.
1. Sous **Registre d'images**, choisissez **Autre registre**.
1. Dans le champ **URL du registre externe**, suivez la [AWS Mainframe Modernization contenant](assembler-conversion-components-process.md#assembler-conversion-components-container) section.
1. Sous **Rôle de service**, choisissez **Rôle de service existant**, puis dans le champ **ARN du rôle**, choisissez le rôle de service que vous avez créé précédemment, par exemple,`IAMRoleTaskExecutionRoleForCodeBuild`.
1. Développez la section **Configuration supplémentaire**, procédez comme suit :
1. VPC : configurez si nécessaire en fonction de votre configuration.
1. Délai d'attente : réglé sur **60 minutes.**
1. **Délai d'attente : défini sur 480 minutes.**
1. Chiffrement : Choisissez les paramètres de chiffrement appropriés (la valeur par défaut est correcte).
1. Dans la section **Variables d'environnement**, ajoutez les éléments suivants un par un :
+ Nom : **PROJECT\$1BUCKET**. Valeur :`codebuild-regionId-accountId-bucket`. Type : texte **brut**
+ Nom : **PROJECT\$1DIR**. Valeur :`prj_codebuild_01`. Type : texte **brut**
+ Nom : **AWSM2CCM\$1ACTION**. Valeur :`conversion`. Type : texte **brut**
+ Nom : **AWSM2CCM\$1LOGGING\$1BUCKET**. Valeur :`s3:// codebuild-regionId-accountId-bucket`. Type : texte **brut**
1. Dans la section **Buildspec**, choisissez **Insérer des commandes de construction**, puis **Basculer vers** l'éditeur.
1. Remplacez les valeurs actuelles par les suivantes :
```
version: 0.2
phases:
build:
commands:
- export AWSM2CCM_PUSH_RUNTIME_COPYBOOKS=y
- ln -s $CODEBUILD_SRC_DIR $PROJECT_DIR
- . /app/awsm2ccm_prod/bin/setup_env.sh
- run_awsm2ccm.sh $PROJECT_DIR
artifacts:
files:
- '*.log'
- '_Converted/*/*'
- '_Reports/*'
discard-paths: no
base-directory: $PROJECT_DIR
```
où PROJECT\$1DIR sont des variables d'environnement disponibles dans. CodeBuild Pour plus d'informations, consultez la section [Variables d'environnement dans les environnements de génération](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html).
1. Dans la section **Artefacts**, procédez comme suit :
+ sous **Type**, choisissez **Amazon S3**, puis choisissez votre compartiment de sortie (par exemple,`codebuild-regionId-accountId-bucket`).
+ dans le **champ Path**, saisissez **ARTIFACTS**.
+ pour **Nom**, entrez`prj_codebuild_01`.
+ **pour l'**emballage d'Artifact**, sélectionnez Aucun.**
+ pour **Remplacer le nom de l'artefact**, décochez cette option.
+ pour **le chiffrement**, laissez les paramètres par défaut.
1. Pour la section **Logs**, procédez comme suit :
+ CloudWatch journaux : **Désactivé**
+ Journaux S3 : **activé**
+ Compartiment: `codebuild-regionId-account-bucket`
+ Chemin du journal : `CODEBUILD-LOGS`
1. Choisissez **Créer un projet de génération**.
## Étape 7 : Définition du projet et téléchargement du code source
Le Define Project définit le dossier du projet et les fichiers de configuration, initialisés avec les configurations par défaut. Au cours de cette étape, vous lancez la construction. Pour cela :
1. Connectez-vous à la AWS CodeBuild console.
1. Dans le volet de navigation de gauche, choisissez **Créer des projets**.
1. Sélectionnez le projet créé précédemment (`1-awsm2ccm-define-project`) à construire
1. Choisissez **Start build**, puis **Start now** pour définir le projet. Une fois la construction lancée, le statut passe à *En cours*.
1. Choisissez **les détails de la phase** pour voir la progression de chaque étape orchestrée par le AWS CodeBuild projet.
1. Attendez que le statut ait changé pour **réussir** toutes les étapes.
1. Accédez à la console Amazon S3.
1. Localisez et cliquez sur le compartiment Amazon S3 nommé `codebuild-regionId-accountId-bucket`
+ **`CODEBUILD-LOGS/`**le dossier contient les AWS CodeBuild journaux des AWS CodeBuild projets en cours d'exécution.
+ **`prj_codebuild_01/`**dossier contenant la structure du projet. Il est utilisé lors des étapes d'analyse, d'expand\$1macros et de conversion. Vous pouvez choisir `prj_codebuild_01/` d'explorer les détails
+ **`cobol_reserved.rsw`**fichier de configuration (liste de mots COBOL) réservé au convertisseur. Il est utilisé lors de l'étape de conversion.
+ **`Macro_Expansion/`**le dossier contient des macros à étendre aux programmes Assembler. Il est utilisé lors de l'étape expand\$1macros.
+ **`macro_settings.json`**le fichier de configuration contient le remplacement personnalisé des macros. Il est utilisé lors de l'étape expand\$1macros.
+ **`macrolib/`**le dossier contient les macros Assembler à convertir. Il est utilisé lors de l'étape d'analyse et de conversion.
1. Sélectionnez `macrolib/`.
1. Par défaut, une macro Assembler nommée `MACRO1.mac` est fournie sous forme de fichier d'exemple. Supprimez ce fichier car il n'est pas nécessaire pour l'analyse.
1. Téléchargez vos macros dans ce répertoire.
+ **`project_settings_aux.json`**le fichier de configuration contient les paramètres liés à la page de code. Il est utilisé lors de l'étape de conversion.
+ **`project_settings.json`**le fichier de configuration contient les paramètres du convertisseur. Il est utilisé lors de l'étape de conversion.
+ **`srclib/`**le dossier contient les programmes Assembler à convertir. Il est utilisé lors de l'étape d'analyse et de conversion.
1. Sélectionnez `srclib/`.
1. Par défaut, deux programmes Assembler sont nommés `SQtest01.asm` et `SQtest02.asm` sont fournis en tant qu'exemples. Supprimez ces fichiers car ils ne sont pas nécessaires à votre analyse et à votre conversion.
1. Téléchargez vos programmes Assembler dans ce répertoire.
1. Vérifiez le statut de l'`1-awsm2ccm-define-project`étape. Cela aurait dû réussir sous l'onglet **État de la dernière version**.
Vous êtes prêt pour l'étape suivante : l'**analyse du code**.
## Étape 8 : Exécuter l'analyse et comprendre les rapports
**Note**
AWS Mainframe Modernization *L'étape d'analyse* de la conversion du code est gratuite.
Au cours de cette étape, vous lancez un autre build :
1. Dans le volet de navigation de gauche, choisissez **Créer des projets**.
1. Choisissez le projet que vous avez créé à l'étape 6.2 pour créer :`2-awsm2ccm-analysis`.
1. Choisissez **Start build**, puis **Start now** pour générer des rapports d'analyse. Cela permettra de démarrer la construction et de passer à l'état *en cours*.
1. Choisissez **les détails de la phase** où vous pourrez voir la progression de chaque étape orchestrée par le AWS CodeBuild projet. Attendez que le changement de statut soit terminé pour *que* toutes les étapes soient terminées.
1. À partir du AWS Management Console, accédez à la console de service Amazon S3.
1. Localisez et cliquez sur le compartiment Amazon S3 : `codebuild-regionId-accountId-bucket`
1. **`ARTIFACTS/`**le dossier contient les résultats des étapes d'*analyse* et de *conversion*.
1. Sélectionnez `ARTIFACTS/prj_codebuild_01/_Reports/`.
1. Les rapports suivants seront disponibles :
+ `AWSM2CCM-Analysis-Report-.pdf`est un rapport exécutif qui fournit la facturation et le champ d'application de la conversion du AWS Mainframe Modernization Code, l'amélioration de la conversion, le résumé des conversions et les statistiques de conversion détaillées. Il résume également le nombre de codes et le nombre de codes facturables au niveau du projet et fournit des mesures et des listes de membres référencés pour chaque composant. Il est essentiel d'exécuter et d'examiner ce rapport avant d'exécuter la conversion proprement dite.
+ `Conversion_Detailed_Statistics.txt`fournit la fréquence et le résultat de conversion attendu (affiché sous la forme « État de conversion ») pour chaque instruction trouvée dans chaque composant. Cela fournit un moyen rapide de déterminer si les instructions sont claires et que le convertisseur ne les prend pas en charge. Les résultats possibles *de l'état de conversion* sont les suivants :
+ **Totalement convertie** : l'instruction sera convertie avec précision en COBOL.
+ **Partiellement convertie** : l'instruction est prise en charge mais utilise un paramètre ou une expression non pris en charge. Des ajustements manuels sont probablement nécessaires après la conversion.
+ **Non convertie** : l'instruction n'est pas prise en charge par le convertisseur.
+ **Instructions de pré-compilation pour vérifier** : elles sont normalement incluses dans les macros et font référence à ce que l'on appelle probablement aussi les instructions du *langage d'assemblage conditionnel* (par exemple, AIF, AGO) sur le mainframe. Elles sont gérées par le précompilateur, qui est piloté par de telles instructions ou directives, sélectionne et produit du code ASM *propre/statique*. Ces instructions dépendent des valeurs réelles des paramètres de macro qui sont compilés. Ainsi, la même macro peut générer différents morceaux de code ASM, en fonction des valeurs des paramètres transmis. Cela est dû à la présence de telles *instructions de pré-compilation*. Dans ce cas, envisagez d'étendre ou de réorganiser la macro.
+ `Conversion_Global_Statistics.txt`fournit un résumé de l'*état de la conversion* au niveau d'un composant.
+ `CrossReference_PgmToCpyMacro.txt`rapports sur les dépendances du programme Assembler sur les macros. Il fournit un moyen rapide de déterminer si des macros sont absentes du code téléchargé.
+ `CrossReference_PgmToPgm.txt`rend compte des dépendances du programme Assembler par rapport à d'autres programmes Assembler. Il fournit un moyen rapide de déterminer si des programmes Assembler sont absents du code téléchargé.
1. Retournez à la console AWS CodeBuild de service.
1. Vérifiez l'état de l'étape **2-awsm2ccm-analysis**. Cela aurait dû **réussir** sous l'onglet **État de la dernière version**.
Vous êtes prêt pour l'étape suivante : la **conversion du code**.
## Étape 9 : Exécuter la conversion du code
**Important**
AWS Mainframe Modernization L'étape de *conversion* du code sera facturée en fonction de votre utilisation. Pour de plus amples informations sur la facturation, veuillez consulter [Comprendre la facturation de la conversion de code pour la conversion d'un assembleur](assembler-conversion-billing.md).
Au cours de cette étape, vous allez configurer le processus de conversion, puis démarrer la génération.
1. À partir du AWS Management Console, accédez au service Amazon S3.
1. Localisez et cliquez sur le compartiment Amazon S3 :`codebuild-regionId-accountId-bucket`.
1. Accédez à `prj_codebuild_01/`.
1. Sélectionnez`project_settings.json`, puis choisissez **Télécharger**.
1. Ouvrez le `project_settings.json` fichier pour voir la structure JSON suivante :
```
{
"Source programs directory":"srclib",
"Source copybooks/macros directory":"macrolib",
"Copybook/Macros Conversion":"Called_only",
"Do not regenerate the Copy/Macro if already exists":"false",
"Target Compiler":"IBM",
"Endianess":"Big",
"Converted programs extension":"",
"Converted CICS programs extension":"",
"Converted copies/macros extension":"",
"Trace Level":"STANDARD",
"Trace file open mode":"append",
"Data definition level":5,
"Start picture column":40,
"Generate Sync FILLER with name":"FILL-SYNC",
"Use SYNC clause":"yes",
"Decimal Point Comma":"true",
"Original Source Placement":"RIGHT"
}
```
Où :
+ **Répertoire du programme source** : contient les programmes Assembler nécessaires à la conversion.
+ **Répertoire source Copybooks/macros** : contient les macros Assembler et les cahiers nécessaires à la conversion.
+ La **conversion des copybooks/macros peut être soit** :
+ **Tout** : Ce bouton radio indique que la *conversion complète* convertira toutes les copybook/Macros informations disponibles dans le répertoire, qu'elles soient utilisées ou non par les programmes.
+ **Called\$1only** : Ce bouton radio indique que la *conversion complète* ne convertira que le contenu réellement utilisé par les copybook/Macros programmes.
+
**Important**
Vous n'avez pas besoin de le régénérer Copy/Macro s'il existe déjà.
Lorsque cela est vrai, l'outil ne convertira pas à nouveau le copybook/macro s'il est déjà converti (il existe dans le dossier de sortie).
+ **Cible** : La conversion des programmes (code généré) dépend du compilateur COBOL cible. Les options suivantes sont prises en charge :
+ « IBM » pour mainframe IBM
+ « MF » pour Micro Focus COBOL
+ « VERYANT » pour Veryant iScobol
+ « NTT » pour NTT DATA Enterprise COBOL (Unikix)
+ **Endianess et bitness : La conversion des programmes (code généré) dépend de la plateforme cible (bits/endianess**). Cette combinaison permet de sélectionner les options prises en charge suivantes :
+ Endianess : *Big* (pour Big-Endian) /Little (Little-Endian). Par exemple, le z/OS mainframe IBM est Big-Endian, Windows est Little-Endian, Linux varie selon les distributions (par exemple, Amazon Linux 2 sur EC2 est Little-Endian).
+ Bitness : 32/64 (s'il n'est pas indiqué, la valeur par défaut sera 32). Le réglage recommandé est de 32 bits.
+ **Extension du programme converti** : Il s'agit de définir l'extension de fichier pour les programmes COBOL générés. Vide (« ») : aucune extension. Pour les cibles COBOL de Rocket Software (anciennement Micro Focus), *CBL* est recommandé pour permettre à Rocket Enterprise Developer de reconnaître correctement les fichiers.
+ **Extension de programme CICS convertie** : Ceci permet de définir l'extension de fichier pour les programmes CICS COBOL générés. Vide (« ») : aucune extension. Pour les cibles COBOL de Rocket Software, *CBL* est recommandé pour permettre à Rocket Enterprise Developer de reconnaître correctement les fichiers.
+ Extension de **copybooks/macros convertis : Ceci permet de définir l'extension** de fichier pour les copybooks COBOL générés. Vide (« ») : aucune extension. Pour les cibles COBOL de Rocket Software, le *CPY* est recommandé pour permettre à Rocket Enterprise Developer de reconnaître correctement les fichiers.
+ **Niveau de trace** : le traçage est l'information enregistrée CodeBuild lors de la conversion. L'utilisateur peut sélectionner le niveau de détail en sélectionnant l'une des options proposées.
+ **ERREUR = ERREUR** DE TRACE : seules les erreurs de conversion sont affichées.
+ **STANDARD** = TRACE STANDARD : les erreurs de conversion et les informations standard sont affichées. Il s'agit du paramètre recommandé.
+ **TOUT** = TRACE TOUT : niveau de traçage maximal
+ **Mode d'ouverture du fichier de trace** : non utilisé. Le paramètre par défaut *d'ajout* est recommandé.
+ **Niveau de définition des données** : Cela indique le niveau initial des sous-champs (après le niveau « 01 ») définis dans la section « work-storage » et « couplage ». Ça doit être un chiffre.
+ **Colonne d'image de départ** : elle concerne le format du code COBOL généré et indique la colonne dans laquelle la clause *PIC* est placée (après les noms des champs). Ça doit être un chiffre.
+ **Emplacement de la source d'origine :** cela indique la position où les commentaires sont placés dans le programme. Deux options s'offrent à vous :
+ **DROITE** : Cette option placera le commentaire ou les informations supplémentaires à la bonne position après la soixante-treizième (73) colonne. En COBOL, le code est écrit dans les soixante-douze premières (1-72) colonnes et tout ce qui se trouve dans la soixante-treizième colonne (>= 73) sera traité comme un commentaire.
+ **CI-DESSUS** : Cette option placera le commentaire au-dessus du contenu traduit.
+ **Générer un fichier de synchronisation avec le nom** : cette option est liée à l'alignement en mémoire des champs binaires (types de données Assembler « H », « F », « D », qui sont convertis en type de données COBOL « COMP »). Afin de garantir la bonne *limite d'alignement*, des champs de *remplissage* explicites seront ajoutés lors de la conversion. Il s'agit d'une option basée sur du texte, la valeur doit être une chaîne (comme FILL-SYNC).
+ **Utiliser la clause SYNC** : cette option fait référence à l'alignement en mémoire des champs binaires. Oui = tous les champs sont convertis en COBOL. « COMP » sera défini avec la clause « SYNC » (par exemple, 05 WRKFLD PIC S9 (09) COMP SYNC).
+ Virgule **décimale** : lorsque cela est vrai, la clause *DECIMAL-POINT IS COMMA sera ajoutée au paragraphe COBOL « SPECIAL-NAMES* ».
1. En fonction de vos besoins, modifiez les paramètres appropriés, puis enregistrez le`project_settings.json`.
1. Supprimez le `project_settings.json` fichier existant `prj_codebuild_01/` du compartiment Amazon S3, puis chargez la nouvelle version.
1. Retournez au AWS CodeBuild service.
1. Sélectionnez le projet à construire que vous avez créé précédemment : `3-awsm2ccm-convert`
1. Choisissez **Start build**, puis **Start now** pour convertir les programmes Assembler et les macros en programmes COBOL et en copybooks.
1. Attendez que le statut de construction passe à **Successed** pour ce projet. Il se trouvera sous l'onglet **État de la dernière version**.
## Étape 10 : Vérifiez la conversion du code
1. À partir du AWS Management Console, accédez au service Amazon S3.
1. Localisez et cliquez sur le compartiment Amazon S3 :`codebuild-regionId-accountId-bucket`.
1. Naviguez vers **`awsm2ccm-do-not-delete `**. AWS Mainframe Modernization La conversion de code crée des fichiers binaires codés pour chaque module Assembler ou Macro pendant le processus de conversion. Ces fichiers sont essentiels pour éviter la double facturation aux clients et pour suivre la quantité de code Assembler fourni qui a été analysée et convertie. Les fichiers sont stockés à l'emplacement suivant : `codebuild-regionId-accountId- bucket/awsm2ccm-do-not-delete//Hash` Les fichiers encodés ne contiennent aucun code assembleur et il n'est pas non plus possible d'extraire le code client de ces fichiers.
**Important**
Vous ne devez ni modifier manuellement ces fichiers ni les supprimer. La modification ou la suppression de ces fichiers peut entraîner plusieurs facturations pour les mêmes composants.
Traitez le **`awsm2ccm-do-not-delete/`**dossier comme un répertoire géré par le système. Consultez Support avant d'apporter des modifications à ce répertoire ou à son contenu.
1. Cliquez `codebuild-regionId-accountId-bucket` pour revenir au compartiment.
1. Choisissez **`ARTIFACTS/prj_codebuild_01/`**. Le dossier **\$1Converted/** contient les sorties COBOL générées à la suite de l'étape de conversion du code. Il comportera les sous-répertoires suivants :
+ Le dossier **copybooks/** contient les copybooks COBOL générés.
+ le dossier **programs/** contient les programmes COBOL générés.
+ Le dossier **runtime\$1lib/** contient des programmes COBOL et des copybooks supplémentaires fournis par la solution.
1. Si les *rapports d'analyse* et les autres rapports indiquent que la conversion a été réussie et que le AWS CodeBuild projet `3-awsm2ccm-convert` est marqué comme **réussi**, téléchargez le code COBOL et les cahiers depuis le répertoire **\$1Converted/**.
## Étape 11 : Téléchargez le code converti
Au cours de cette étape, téléchargez le code COBOL et les cahiers depuis le répertoire **\$1Converted/**, puis compilez-les dans l'environnement COBOL cible.
1. À partir du AWS Management Console, accédez au service Amazon S3.
1. Localisez et cliquez sur le compartiment Amazon S3 :`codebuild-regionId-accountId-bucket`.
1. Accédez à l'emplacement :` ARTIFACTS/prj_codebuild_01/_Converted/`.
1. **Téléchargez le code COBOL converti depuis tous les sous-répertoires sous \$1Converted/.** Vous pouvez également utiliser la commande CLI suivante pour les télécharger en une seule fois :
```
aws s3 cp s3://codebuild-regionId-accountId-
bucket/ARTIFACTS/prj_codebuild_01/_Converted/ . --recursive
```
1. Analysez et compilez le COBOL converti dans l'environnement COBOL cible.
## nettoyer des ressources ;
Si vous n'avez plus besoin des ressources que vous avez créées pour ce didacticiel, supprimez-les pour éviter des frais supplémentaires. Pour ce faire, exécutez les étapes suivantes :
+ Supprimez les compartiments S3 que vous avez créés pour ce didacticiel. Pour plus d'informations, consultez [Supprimer un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) dans le *guide de l'utilisateur d'Amazon Simple Storage Service*.
+ Supprimez les politiques IAM que vous avez créées pour ce didacticiel. Pour plus d'informations, consultez [la section Suppression des politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-delete.html) dans le guide de l'*utilisateur IAM*.
+ Supprimez le rôle IAM que vous avez créé pour ce didacticiel. Pour plus d'informations, consultez [la section Suppression de rôles ou de profils d'instance](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html) dans le *guide de l'utilisateur IAM*.
+ Supprimez le CodeBuild projet que vous avez créé pour ce didacticiel. Pour plus d'informations, voir [Supprimer un projet de construction CodeBuild dans](https://docs.aws.amazon.com/codebuild/latest/userguide/delete-project.html) le *guide de AWS CodeBuild l'utilisateur*.