Amazon n' CodeCatalyst est plus ouvert aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [Comment effectuer une migration depuis CodeCatalyst](migration.md).
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.
# Élaboration d'un plan personnalisé pour répondre aux exigences du projet
Avant de publier un plan personnalisé, vous pouvez le développer pour répondre à des exigences spécifiques. Vous pouvez développer votre plan personnalisé et le tester en créant un projet lors de la prévisualisation. Vous pouvez développer le plan personnalisé pour inclure les composants du projet, tels que le code source spécifique, les connexions aux comptes, les flux de travail, les problèmes ou tout autre composant pouvant être créé dans CodeCatalyst.
**Important**
Si vous souhaitez utiliser des packages de plans provenant de sources externes, prenez en compte les risques qui peuvent découler de ces packages. Vous êtes responsable des plans personnalisés que vous ajoutez à votre espace et du code qu'ils génèrent.
**Important**
Pour développer un plan personnalisé dans votre CodeCatalyst espace, vous devez être connecté avec un compte doté du rôle d'**administrateur de l'espace** ou **d'utilisateur avancé** dans l'espace.
**Pour développer ou mettre à jour un plan personnalisé**
1. Reprenez votre environnement de développement. Pour de plus amples informations, veuillez consulter [Reprise d'un environnement de développement](devenvironment-resume.md).
Si vous n'avez pas d'environnement de développement, vous devez d'abord en créer un. Pour de plus amples informations, veuillez consulter [Création d’un environnement de développement](devenvironment-create.md).
1. Ouvrez un terminal fonctionnel dans votre environnement de développement.
1. Si vous avez opté pour un flux de publication lors de la création de votre plan, la dernière version du plan est automatiquement publiée. Extrayez les modifications pour vous assurer que le `package.json` fichier possède la version incrémentée. Utilisez la commande suivante :
```
git pull
```
1. Dans le `src/blueprint.ts` fichier, modifiez les options de votre plan personnalisé. L'`Options`interface est interprétée dynamiquement par l' CodeCatalyst assistant pour générer une interface utilisateur (UI) de sélection. Vous pouvez développer votre plan personnalisé en ajoutant des composants et des balises compatibles. Pour plus d'informations, consultez [Modification des fonctionnalités du plan à l'aide d'un assistant frontal](wizard-bp.md), [Ajouter des composants d'environnement à un plan](comp-env-bp.md), [Ajouter des composants régionaux à un plan](region-comp-bp.md), [Ajouter des composants de référentiel et de code source à un plan](comp-repo-source-bp.md), [Ajouter des composants de flux de travail à un plan](comp-workflow-bp.md) et [Ajouter des composants d'environnements de développement à un plan](comp-dev-env-bp.md).
Vous pouvez également consulter le SDK de plans et des exemples de plans pour bénéficier d'une assistance supplémentaire lors du développement de votre plan personnalisé. Pour plus d'informations, consultez le [ GitHub référentiel open source.](https://github.com/aws/codecatalyst-blueprints)
Les plans personnalisés fournissent des ensembles de prévisualisation à la suite d'une synthèse réussie. Le bundle de projets représente le code source, la configuration et les ressources d'un projet, et il est utilisé par les opérations d'API de CodeCatalyst déploiement pour le déploiement dans un projet. Si vous souhaitez continuer à développer votre plan personnalisé, relancez le processus de synthèse du plan. Pour de plus amples informations, veuillez consulter [Concepts de plans personnalisés](custom-bp-concepts.md).
# Modification des fonctionnalités du plan à l'aide d'un assistant frontal
Un assistant de sélection de plans activé CodeCatalyst est généré automatiquement par l'`Options`interface du fichier. `blueprint.ts` L'assistant frontal prend en charge les modifications et les fonctionnalités d'un plan à l'`Options`aide de [commentaires et de balises de style JSDOC](https://jsdoc.app/about-getting-started.html). Vous pouvez utiliser des commentaires et des balises de style JSDOC pour effectuer des tâches. Par exemple, vous pouvez sélectionner le texte affiché au-dessus d'une option, activer des fonctionnalités telles que la validation des entrées ou rendre une option pliable. L'assistant fonctionne en interprétant un arbre syntaxique abstrait (AST) généré à partir du TypeScript type de l'`Options`interface. L'assistant se configure automatiquement selon le type décrit du mieux qu'il peut. Tous les types ne sont pas pris en charge. Les autres types pris en charge incluent le sélecteur de région et le sélecteur d'environnement.
Voici un exemple d'assistant qui utilise des commentaires et des balises JSDOC avec des plans : `Options`
```
export interface Options {
/**
* What do you want to call your new blueprint?
* @validationRegex /^[a-zA-Z0-9_]+$/
* @validationMessage Must contain only upper and lowercase letters, numbers and underscores
*/
blueprintName: string;
/**
* Add a description for your new blueprint.
*/
description?: string;
/**
* Tags for your Blueprint:
* @collapsed true
*/
tags?: string[];
}
```
Le nom d'affichage de chaque option de l'`Options`interface apparaît `camelCase` par défaut. Le texte brut dans le commentaire de style JSDOC est affiché sous forme de texte au-dessus de l'option dans l'assistant.
**Topics**
+ [Tags pris en charge](#supported-tags-bp)
+ [TypeScript Types pris en charge](#supported-typescript-bp)
+ [Communiquer avec l'utilisateur lors de la synthèse](#communication-mid-synthesis)
## Tags pris en charge
Les balises JSDOC suivantes sont prises en charge par un plan personnalisé `Options` dans l'assistant frontal.
### @inlinePolicy. /path/to/policy/file.json
+ **Nécessite** : l'option doit être un type`Role`.
+ **Utilisation** : vous permet de communiquer les politiques intégrées dont un rôle a besoin. Le `policy.json` chemin devrait se trouver sous le code source. Utilisez cette balise lorsque vous avez besoin d'une politique personnalisée pour un rôle.
+ **Dépendances** - `blueprint-cli 0.1.12` et supérieures
+ **Exemple** - `@inlinePolicy ./deployment-policy.json`
```
environment: EnvironmentDefinition{
awsAccountConnection: AccountConnection{
/**
* @inlinePolicy ./path/to/deployment-policy.json
*/
cdkRole: Role[];
};
};
```
### @trustPolicy. /path/to/policy/file.json
+ **Nécessite** : l'option doit être un type`Role`.
+ **Utilisation** : vous permet de communiquer les politiques de confiance dont un rôle a besoin. Le `policy.json` chemin devrait se trouver sous le code source. Utilisez cette balise lorsque vous avez besoin d'une politique personnalisée pour un rôle.
+ **Dépendances** - `blueprint-cli 0.1.12` et supérieures
+ **Exemple** - `@trustPolicy ./trust-policy.json`
```
environment: EnvironmentDefinition{
awsAccountConnection: AccountConnection{
/**
* @trustPolicy ./path/to/trust-policy.json
*/
cdkRole: Role[];
};
};
```
### Expression Regex @validationRegex
+ **Nécessite** : l'option doit être une chaîne.
+ **Utilisation** - Effectue la validation des entrées sur l'option en utilisant l'expression regex donnée et les affichages`@validationMessage`.
+ **Exemple** - `@validationRegex /^[a-zA-Z0-9_]+$/`
+ **Recommandation** - À utiliser avec`@validationMessage`. Le message de validation est vide par défaut.
### chaîne @validationMessage
+ **Nécessite** des erreurs `@validationRegex` ou d'autres erreurs pour vérifier l'utilisation.
+ **Utilisation** : affiche un message de validation en `@validation*` cas d'échec.
+ **Exemple** -`@validationMessage Must contain only upper and lowercase letters, numbers, and underscores`.
+ **Recommandation** - À utiliser avec`@validationMessage`. Le message de validation est vide par défaut.
### @collapsed boolean (facultatif)
+ **Nécessite** - N/A
+ **Utilisation** : booléen permettant à une sous-option d'être repliable. Si l'annotation réduite est présente, sa valeur par défaut est vraie. La définition de la valeur sur `@collapsed false` crée une section pliable qui est initialement ouverte.
+ **Exemple** - `@collapsed true`
### chaîne @displayName
+ **Nécessite** - N/A
+ **Utilisation** - Modifie le nom d'affichage de l'option. Autorise des formats autres que CamelCase pour le nom d'affichage.
+ **Exemple** - `@displayName Blueprint Name`
### chaîne @displayName
+ **Nécessite** - N/A
+ **Utilisation** - Modifie le nom d'affichage de l'option. Autorise des formats autres que [CamelCase](https://en.wikipedia.org/wiki/Camel_case) pour le nom d'affichage.
+ **Exemple** - `@displayName Blueprint Name`
### Numéro @defaultEntropy
+ **Nécessite** : l'option doit être une chaîne.
+ **Utilisation** : ajoute une chaîne alphanumérique aléatoire d'une longueur spécifiée à l'option.
+ **Exemple** - `@defaultEntropy 5`
### chaîne @placeholder (facultatif)
+ **Nécessite** - N/A
+ **Utilisation - Modifie l'**espace réservé aux champs de texte par défaut.
+ **Exemple** - `@placeholder type project name here`
### Numéro @textArea (facultatif)
+ **Nécessite** - N/A
+ **Utilisation** - Convertit l'entrée de chaîne en un composant de zone de texte pour les grandes sections de texte. L'ajout d'un nombre définit le nombre de lignes. La valeur par défaut est de cinq lignes.
+ **Exemple** - `@textArea 10`
### @hidden boolean (facultatif)
+ **Nécessite** - N/A
+ **Utilisation** : masque le fichier à l'utilisateur sauf si le contrôle de validation échoue. La valeur par défaut est true.
+ **Exemple** - `@hidden`
### @button boolean (facultatif)
+ **Nécessite** - N/A
+ **Utilisation : l'**annotation doit figurer sur une propriété booléenne. Ajoute un bouton qui sera synthétisé comme vrai une fois sélectionné. Ce n'est pas une bascule.
+ **Exemple** - `buttonExample: boolean;`
```
/**
* @button
*/
buttonExample: boolean;
```
### @showName boolean (facultatif)
+ **Nécessite** - N/A
+ **Utilisation** : ne peut être utilisé que sur un type de connexion à un compte. Affiche le nom masqué saisi. La valeur par défaut est `default_environment`.
+ **Exemple** - `@showName true`
```
/**
* @showName true
*/
accountConnection: AccountConnection<{
...
}>;
```
### @ showEnvironmentType boolean (facultatif)
+ **Nécessite** - N/A
+ **Utilisation** : ne peut être utilisé que sur un type de connexion à un compte. Affiche le menu déroulant des types d'environnement masqués. Toutes les connexions sont définies par défaut sur`production`. Les options sont **la non-production ou la** **production**.
+ **Exemple** - `@showEnvironmentType true`
```
/**
* @showEnvironmentType true
*/
accountConnection: AccountConnection<{
...
}>;
```
### @forceDefault boolean (facultatif)
+ **Nécessite** - N/A
+ **Utilisation** : utilise la valeur par défaut fournie par l'auteur du plan au lieu de la valeur utilisée précédemment par l'utilisateur.
+ **Exemple** - `forceDeafultExample: any;`
```
/**
* @forceDefault
*/
forceDeafultExample: any;
```
### Nom du plan @requires
+ **Nécessite** : annote l'`Options`interface.
+ **Utilisation** : avertit l'utilisateur d'ajouter un `blueprintName` élément spécifié au projet comme exigence pour le plan actuel.
+ **Exemple** - `@requires '@amazon-codecatalyst/blueprints.blueprint-builder'`
```
/*
* @requires '@amazon-codecatalyst/blueprints.blueprint-builder'
*/
export interface Options extends ParentOptions {
...
```
### @filter regex
+ **Nécessite** : annote l'`MultiSelect`interface `Selector` or.
+ **Utilisation** : filtre le menu déroulant dans l'assistant pour afficher les options correspondant à l'expression régulière spécifiée.
+ **Exemple** - `@filter /blueprintPackageName/`
```
/**
* @filter /myPackageName/
*/
blueprintInstantiation?: Selector;
...
```
## TypeScript Types pris en charge
Les TypeScript types suivants sont pris en charge par un plan personnalisé `Options` dans l'assistant frontal.
### Nombre
+ **Nécessite** : l'option doit être un type`number`.
+ **Utilisation** - Générez un champ de saisie numérique.
+ **Exemple** - `age: number`
```
{
age: number
...
}
```
### Chaîne
+ **Nécessite** : l'option doit être un type`string`.
+ **Utilisation** - Génère un champ de saisie de chaîne.
+ **Exemple** - `name: string`
```
{
age: string
...
}
```
### Liste de chaînes
+ **Nécessite** : l'option doit être un tableau de types`string`.
+ **Utilisation** - Génère une entrée de liste de chaînes.
+ **Exemple** - `isProduction: boolean`
```
{
isProduction: boolean
...
}
```
### Checkbox
+ **Nécessite** : option pour être un`boolean`.
+ **Utilisation** - Générez une case à cocher.
+ **Exemple** - `isProduction: boolean`
```
{
isProduction: boolean
...
}
```
### Radio
+ **Nécessite** : cette option doit être une union de trois chaînes ou moins.
+ **Utilisation** - Génère une radio sélectionnée.
**Note**
Lorsqu'il y a quatre éléments ou plus, ce type s'affiche sous forme de liste déroulante.
+ **Exemple** - `color: 'red' | 'blue' | 'green'`
```
{
color: 'red' | 'blue' | 'green'
...
}
```
### Liste déroulante
+ **Nécessite** : option devant être une union de quatre chaînes ou plus.
+ **Utilisation** : générez une liste déroulante.
+ **Exemple** - `runtimes: 'nodejs' | 'python' | 'java' | 'dotnetcore' | 'ruby'`
```
{
runtimes: 'nodejs' | 'python' | 'java' | 'dotnetcore' | 'ruby'
...
}
```
### Section extensible
+ **Nécessite** : option pour être un objet.
+ **Utilisation** - Générez une section extensible. Les options de l'objet seront imbriquées dans la section extensible de l'assistant.
+ **Exemple** -
```
{
expandableSectionTitle: {
nestedString: string;
nestedNumber: number;
}
}
```
### Tuple
+ **Nécessite** : l'option doit être de type`Tuple`.
+ **Utilisation** - Générez une entrée payante à valeur clé.
+ **Exemple** - `tuple: Tuple[string, string]>`
```
{
tuple: Tuple[string, string]>;
...
}
```
### Liste de tuples
+ **Nécessite** : l'option doit être un tableau de types`Tuple`.
+ **Utilisation** - Générez une entrée de liste de tuples.
+ **Exemple** - `tupleList: Tuple[string, string]>[]`
```
{
tupleList: Tuple[string, string]>[];
...
}
```
### Selector
+ **Nécessite** : l'option doit être de type`Selector`.
+ **Utilisation** : générez une liste déroulante des référentiels sources ou des plans appliqués à un projet.
+ **Exemple** - `sourceRepo: Selector`
```
{
sourceRepo: Selector;
sourceRepoOrAdd: Selector;
blueprintInstantiation: Selector;
...
}
```
### Sélection multiple
+ **Nécessite** : l'option doit être de type`Selector`.
+ **Utilisation** - Génère une entrée à sélection multiple.
+ **Exemple** - `multiselect: MultiSelect['A' | 'B' | 'C' | 'D' | 'E']>`
```
{
multiselect: MultiSelect['A' | 'B' | 'C' | 'D' | 'E']>;
...
}
```
## Communiquer avec l'utilisateur lors de la synthèse
En tant qu'auteur d'un plan, vous pouvez communiquer avec les utilisateurs au-delà des simples messages de validation. Par exemple, un membre de l'espace peut afficher une combinaison d'options qui produit un plan qui n'est pas clair. Les plans personnalisés permettent de communiquer des messages d'erreur aux utilisateurs en invoquant la synthèse. Le plan de base implémente une `throwSynthesisError(...)` fonction qui attend un message d'erreur clair. Vous pouvez appeler le message en utilisant ce qui suit :
```
//blueprint.ts
this.throwSynthesisError({
name: BlueprintSynthesisErrorTypes.BlueprintSynthesisError,
message: 'hello from the blueprint! This is a custom error communicated to the user.'
})
```
# Génération d'entrées et rendu des éléments de l'assistant frontal
Vous pouvez générer des entrées d'assistant avec le Dynamic KVInput et créer dynamiquement des éléments d'assistant frontal pour votre plan personnalisé.
**Topics**
+ [Création d'environnements de développement](#dynamickvinput-bp)
+ [Création dynamique d'éléments d'assistant](#create-wizard-elements-bp)
## Création d'environnements de développement
Le KVInput type Dynamic peut être utilisé pour générer des entrées d'assistant frontal en utilisant les paramètres par défaut de votre plan personnalisé. Pour afficher le up-to-date schéma le plus complet, consultez la [KVInput définition dynamique](https://github.com/aws/codecatalyst-blueprints/blob/main/packages/blueprints/blueprint/src/ui-selectors/dynamic-kv-input.ts).
L'exemple suivant montre comment vous pouvez l'utiliser `Options` pour façonner un objet :
```
import { DynamicKVInput } from '@amazon-codecatalyst/blueprints.blueprint';
export interface Options extends ParentOptions {
parameters: DynamicKVInput[];
}
```
L'exemple suivant montre comment définir des paramètres par défaut à l'aide de plusieurs propriétés :
```
{
"parameters": [
{
"key": "AWS_REGION",
"value": "us-west-2",
"displayType": "region",
"possibleValues": [
"us-west-1",
"us-west-2",
"us-east-1",
"us-east-2"
],
"displayName": "AWS Region",
"description": "AWS Region to deploy the solution to."
},
{
"key": "SchedulingActive",
"value": "Yes",
"displayType": "dropdown",
"possibleValues": [
"Yes",
"No"
],
"displayName": "Scheduling Active",
"description": "Activate or deactivate scheduling."
},
{
"key": "ScheduledServices",
"value": "Both",
"displayType": "dropdown",
"possibleValues": [
"EC2",
"RDS",
"Both"
],
"displayName": "Scheduled Services",
"description": "Services to schedule."
},
{
"key": "ScheduleRdsClusters",
"value": "No",
"displayType": "dropdown",
"possibleValues": [
"Yes",
"No"
],
"displayName": "Schedule RDS Clusters",
"description": "Enable scheduling of Aurora clusters for RDS service."
},
{
"key": "CreateRdsSnapshot",
"value": "No",
"displayType": "dropdown",
"possibleValues": [
"Yes",
"No"
],
"displayName": "Create RDS Snapshot",
"description": "Create snapshot before stopping RDS instances (does not apply to Aurora Clusters)."
},
{
"key": "MemorySize",
"value": "128",
"displayType": "dropdown",
"possibleValues": [
"128",
"384",
"512",
"640",
"768",
"896",
"1024",
"1152",
"1280",
"1408",
"1536"
],
"displayName": "Memory Size",
"description": "Size of the Lambda function running the scheduler, increase size when processing large numbers of instances."
},
{
"key": "UseCloudWatchMetrics",
"value": "No",
"displayType": "dropdown",
"possibleValues": [
"Yes",
"No"
],
"displayName": "Use CloudWatch Metrics",
"description": "Collect instance scheduling data using CloudWatch metrics."
},
{
"key": "LogRetentionDays",
"value": "30",
"displayType": "dropdown",
"possibleValues": [
"1",
"3",
"5",
"7",
"14",
"30",
"60",
"90",
"120",
"150",
"180",
"365",
"400",
"545",
"731",
"1827",
"3653"
],
"displayName": "Log Retention Days",
"description": "Retention days for scheduler logs."
},
{
"key": "Trace",
"value": "No",
"displayType": "dropdown",
"possibleValues": [
"Yes",
"No"
],
"displayName": "Trace",
"description": "Enable debug-level logging in CloudWatch logs."
},
{
"key": "EnableSSMMaintenanceWindows",
"value": "No",
"displayType": "dropdown",
"possibleValues": [
"Yes",
"No"
],
"displayName": "Enable SSM Maintenance Windows",
"description": "Enable the solution to load SSM Maintenance Windows, so that they can be used for EC2 instance Scheduling."
},
{
"key": "DefaultTimezone",
"value": "UTC",
"displayType": "string",
"displayName": "Default Timezone",
"description": "Default timezone to use for scheduling."
},
{
"key": "Regions",
"value": "us-west-2",
"displayType": "string",
"displayName": "Regions",
"description": "List of regions in which instances should be scheduled, leave blank for current region only."
},
{
"key": "UsingAWSOrganizations",
"value": "No",
"displayType": "dropdown",
"possibleValues": [
"Yes",
"No"
],
"displayName": "Using AWS Organizations",
"description": "Use AWS Organizations to automate spoke account registration."
},
{
"key": "Principals",
"displayType": "string",
"optional": false,
"displayName": "Principals",
"description": "(Required) If using AWS Organizations, provide the Organization ID. Eg. o-xxxxyyy. Else, provide a comma separated list of spoke account ids to schedule. Eg.: 1111111111, 2222222222 or {param: ssm-param-name}"
},
{
"key": "Namespace",
"value": "Default",
"displayType": "string",
"displayName": "Namespace",
"description": "Provide unique identifier to differentiate between multiple solution deployments (No Spaces). Example: Dev"
},
{
"key": "SchedulerFrequency",
"value": 5,
"displayType": "number",
"displayName": "Scheduler Frequency",
"description": "Scheduler running frequency in minutes."
}
]
}
```
## Création dynamique d'éléments d'assistant
Le même schéma que celui utilisé pour créer les entrées de l'assistant peut être utilisé pour le rendu dynamique d'un assistant pendant la synthèse. Cela peut être utilisé pour répondre aux questions de suivi d'un utilisateur si nécessaire.
```
//blueprint.ts
export interface Options extends ParentOptions {
...
dynamicOptions: OptionsSchemaDefinition<'optionsIdentifier', KVSchema>;
}
```
L'assistant peut ensuite être configuré pendant la période de synthèse à l'aide d'un `Options` composant.
```
import {
OptionsSchemaDefinition,
OptionsSchema,
} from '@amazon-codecatalyst/blueprints.blueprint';
...
// dynamically renders a number in the place where 'optionsIdentifier' was set in the original options type.
new OptionsSchema(this, 'optionsIdentifier', [
{
"key": "SchedulerFrequency",
"value": 5,
"displayType": "number",
"displayName": "Scheduler Frequency",
"description": "Scheduler running frequency in minutes."
}
]);
```
# Ajouter des composants d'environnement à un plan
L'assistant de création de plans personnalisés est généré dynamiquement à partir de l'`Options`interface exposée via l'assistant. Les plans permettent de générer des composants d'interface utilisateur (UI) à partir de types exposés.
**Pour importer les composants de l'environnement Amazon CodeCatalyst Blueprints**
Dans votre `blueprint.ts` fichier, ajoutez les éléments suivants :
```
import {...} from '@amazon-codecatalyst/codecatalyst-environments'
```
**Topics**
+ [Création d'environnements de développement](#create-dev-env-bp)
+ [Liste des environnements](#list-env-bp)
+ [Exemples d'interfaces fictives](#examples-comp-env-bp)
## Création d'environnements de développement
L'exemple suivant montre comment déployer votre application dans le cloud :
```
export interface Options extends ParentOptions {
...
myNewEnvironment: EnvironmentDefinition{
thisIsMyFirstAccountConnection: AccountConnection{
thisIsARole: Role['lambda', 's3', 'dynamo'];
};
};
}
```
L'interface génère un composant d'interface utilisateur qui demande un nouvel environnement (`myNewEnvironment`) avec une connexion à un seul compte (`thisIsMyFirstAccountConnection`. Un rôle sur la connexion au compte (`thisIsARole`) est également généré avec `['lambda', 's3', 'dynamo']` les capacités de rôle minimales requises. Tous les utilisateurs ne sont pas connectés à un compte. Vous devez donc vérifier s'il n'y a pas de cas où un utilisateur ne connecte pas de compte ou n'associe pas un compte à un rôle. Les rôles peuvent également être annotés avec`@inlinePolicies`. Pour de plus amples informations, veuillez consulter [@inlinePolicy. /path/to/policy/file.json](wizard-bp.md#inline-policy-tag).
Le composant environnemental nécessite un `name` et`environmentType`. Le code suivant est la forme par défaut minimale requise :
```
{
...
"myNewEnvironment": {
"name": "myProductionEnvironment",
"environmentType": "PRODUCTION"
},
}
```
Le composant d'interface utilisateur vous invite ensuite à saisir différents champs. Au fur et à mesure que vous remplissez les champs, le plan prend une forme complètement développée. Il peut être utile d'inclure la maquette complète dans le `defaults.json` fichier à des fins de test et de développement.
## Liste des environnements
La spécification d'un tableau de types `EnvironmentDefinition` générera une liste d'environnements dans l'interface utilisateur de l'assistant.
```
export interface Options extends ParentOptions {
...
/**
@showName readOnly
*/
myEnvironments: EnvironmentDefinition<{
thisIsMyFirstAccountConnection: AccountConnection<{
thisIsARole: Role<['lambda', 's3', 'dynamo']>;
}>;
}>[];
}
```
L'exemple suivant montre les valeurs par défaut d'une liste d'environnements :
```
{
...
"myEnvironments": [
{
"name": "myProductionEnvironment",
"environmentType": "PRODUCTION"
},
{
"name": "myDevelopmentEnvironment",
"environmentType": "DEVELOPMENT"
},
]
}
```
## Exemples d'interfaces fictives
### Interface fictive simple
```
{
...
"thisIsMyEnvironment": {
"name": "myProductionEnvironment",
"environmentType": "PRODUCTION",
"thisIsMySecondAccountConnection": {
"id": "12345678910",
"name": "my-account-connection-name",
"secondAdminRole": {
"arn": "arn:aws:iam::12345678910:role/ConnectedQuokkaRole",
"name": "ConnectedQuokkaRole",
"capabilities": [
"lambda",
"s3",
"dynamo"
]
}
}
}
}
```
### Interface fictive complexe
```
export interface Options extends ParentOptions {
/**
* The name of an environment
* @displayName This is a Environment Name
* @collapsed
*/
thisIsMyEnvironment: EnvironmentDefinition{
/**
* comments about the account that is being deployed into
* @displayName This account connection has an overriden name
* @collapsed
*/
thisIsMyFirstAccountConnection: AccountConnection{
/**
* Blah blah some information about the role that I expect
* e.g. here's a copy-pastable policy: [to a link]
* @displayName This role has an overriden name
*/
adminRole: Role['admin', 'lambda', 's3', 'cloudfront'];
/**
* Blah blah some information about the second role that I expect
* e.g. here's a copy-pastable policy: [to a link]
*/
lambdaRole: Role['lambda', 's3'];
};
/**
* comments about the account that is being deployed into
*/
thisIsMySecondAccountConnection: AccountConnection{
/**
* Blah blah some information about the role that I expect
* e.g. here's a copy-pastable policy: [to a link]
*/
secondAdminRole: Role['admin', 'lambda', 's3', 'cloudfront'];
/**
* Blah blah some information about the second role that I expect
* e.g. here's a copy-pastable policy: [to a link]
*/
secondLambdaRole: Role['lambda', 's3'];
};
};
}
```
### Interface fictive complète
```
{
...
"thisIsMyEnvironment": {
"name": "my-production-environment",
"environmentType": "PRODUCTION",
"thisIsMySecondAccountConnection": {
"id": "12345678910",
"name": "my-connected-account",
"secondAdminRole": {
"name": "LambdaQuokkaRole",
"arn": "arn:aws:iam::12345678910:role/LambdaQuokkaRole",
"capabilities": [
"admin",
"lambda",
"s3",
"cloudfront"
]
},
"secondLambdaRole": {
"name": "LambdaQuokkaRole",
"arn": "arn:aws:iam::12345678910:role/LambdaQuokkaRole",
"capabilities": [
"lambda",
"s3"
]
}
},
"thisIsMyFirstAccountConnection": {
"id": "12345678910",
"name": "my-connected-account",
"adminRole": {
"name": "LambdaQuokkaRole",
"arn": "arn:aws:iam::12345678910:role/LambdaQuokkaRole",
"capabilities": [
"admin",
"lambda",
"s3",
"cloudfront"
]
},
"lambdaRole": {
"name": "LambdaQuokkaRole",
"arn": "arn:aws:iam::12345678910:role/LambdaQuokkaRole",
"capabilities": [
"lambda",
"s3"
]
}
}
},
}
```
# Ajouter des composants secrets à un plan
Les secrets peuvent être utilisés CodeCatalyst pour stocker des données sensibles qui peuvent être référencées dans les flux de travail. Vous pouvez ajouter un secret à votre plan personnalisé et le référencer dans votre flux de travail. Pour de plus amples informations, veuillez consulter [Masquage de données à l'aide de secrets](workflows-secrets.md).
**Pour importer des CodeCatalyst plans Amazon, tapez le type de région**
Dans votre `blueprint.ts` fichier, ajoutez les éléments suivants :
```
import { Secret, SecretDefinition } from '@amazon-codecatalyst/blueprint-component.secrets'
```
**Topics**
+ [Création d'un secret](#comp-create-secrets-bp)
+ [Référencer un secret dans un flux de travail](#comp-reference-secrets-bp)
## Création d'un secret
L'exemple suivant crée un composant d'interface utilisateur qui invite l'utilisateur à saisir une valeur secrète et une description facultative :
```
export interface Options extends ParentOptions {
...
mySecret: SecretDefinition;
}
export class Blueprint extends ParentBlueprint {
constructor(options_: Options) {
new Secret(this, options.secret);
}
```
Le composant secret nécessite un`name`. Le code suivant est la forme par défaut minimale requise :
```
{
...
"secret": {
"name": "secretName"
},
}
```
## Référencer un secret dans un flux de travail
L'exemple de plan suivant crée un secret et un flux de travail qui fait référence à la valeur secrète. Pour de plus amples informations, veuillez consulter [Référencer un secret dans un flux de travail](workflows-secrets.using.md#workflows-using-secrets.using-identifier).
```
export interface Options extends ParentOptions {
...
/**
*
* @validationRegex /^\w+$/
*/
username: string;
password: SecretDefinition;
}
export class Blueprint extends ParentBlueprint {
constructor(options_: Options) {
const password = new Secret(this, options_.password);
const workflowBuilder = new WorkflowBuilder(this, {
Name: 'my_workflow',
});
workflowBuilder.addBuildAction({
actionName: 'download_files',
input: {
Sources: ['WorkflowSource'],
},
output: {
Artifacts: [{ Name: 'download', Files: ['file1'] }],
},
steps: [
`curl -u ${options_.username}:${password.reference} https://example.com`,
],
});
new Workflow(
this,
repo,
workflowBuilder.getDefinition(),
);
}
```
Pour en savoir plus sur l'utilisation de secrets dans CodeCatalyst, voir[Masquage de données à l'aide de secrets](workflows-secrets.md).
# Ajouter des composants régionaux à un plan
Le type de région peut être ajouté à l'`Options`interface de votre plan personnalisé pour générer un composant. Dans l'assistant de plan, vous pouvez saisir une ou plusieurs régions AWS. Le type de gion peut être importé depuis votre plan de base dans votre `blueprint.ts` fichier. Pour plus d'informations, consultez la section [Régions AWS](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/).
**Pour importer des CodeCatalyst plans Amazon, tapez le type de région**
Dans votre `blueprint.ts` fichier, ajoutez les éléments suivants :
```
import { Region } from '@amazon-codecatalyst/blueprints.blueprint'
```
Le paramètre de type de région est un tableau de codes de région AWS parmi lesquels choisir, ou que vous pouvez utiliser `*` pour inclure toutes les régions AWS prises en charge.
**Topics**
+ [Annotations](#region-annotations-bp)
+ [Exemples de composants régionaux](#region-components-examples)
## Annotations
JSDoc des balises peuvent être ajoutées à chaque champ de l'`Options`interface pour personnaliser la façon dont un champ apparaît et se comporte dans l'assistant. Pour le type de région, les balises suivantes sont prises en charge :
+ L'`@displayName`annotation peut être utilisée pour modifier l'étiquette du champ dans l'assistant.
Exemple : `@displayName AWS Region`
+ L'`@placeholder`annotation peut être utilisée pour modifier l'espace réservé du composant de sélection ou de sélection multiple.
Exemple : `@placeholder Choose AWS Region`
## Exemples de composants régionaux
### Choix d'une région dans une liste spécifiée
```
export interface Options extends ParentOptions {
...
/**
* @displayName Region
*/
region: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>;
}
```
### Choix d'une ou de plusieurs régions dans une liste spécifiée
```
export interface Options extends ParentOptions {
...
/**
* @displayName Regions
*/
multiRegion: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>[];
}
```
### Choisir une région AWS
```
export interface Options extends ParentOptions {
...
/**
* @displayName Region
*/
region: Region<['*']>;
}
```
### Choix d'une ou de plusieurs régions dans une liste spécifiée
```
export interface Options extends ParentOptions {
...
/**
* @displayName Regions
*/
multiRegion: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>[];
}
```
# Ajouter des composants de référentiel et de code source à un plan
Un référentiel est utilisé par Amazon CodeCatalyst pour stocker le code. Le référentiel prend un nom en entrée. La plupart des composants sont stockés dans un référentiel, tels que les fichiers de code source, les flux de travail et d'autres composants tels que les environnements de développement gérés (MDE). Le composant du référentiel source exporte également les composants utilisés pour gérer les fichiers et les actifs statiques. Les référentiels sont soumis à des contraintes de nom. Pour de plus amples informations, veuillez consulter [Stockez du code et collaborez sur celui-ci avec des référentiels de sources dans CodeCatalystStockez du code et collaborez sur celui-ci avec des référentiels de sources](source.md).
```
const repository = new SourceRepository(this, {
title: 'my-new-repository-title',
});
```
**Pour importer le référentiel Amazon CodeCatalyst Blueprints et les composants du code source**
Dans votre `blueprint.ts` fichier, ajoutez les éléments suivants :
```
import {...} from '@caws-blueprint-component/caws-source-repositories'
```
**Topics**
+ [Ajouter un fichier](#repo-add-file-bp)
+ [Ajouter un fichier générique](#repo-add-generic-file-bp)
+ [Copier des fichiers](#repo-copy-file-bp)
+ [Cibler plusieurs fichiers](#target-multiple-files-bp)
+ [Création d'un nouveau dépôt et ajout de fichiers](#repo-code-examples-bp)
## Ajouter un fichier
Vous pouvez écrire un fichier texte dans un dépôt à l'aide de cette `SourceFile` construction. L'opération est l'un des cas d'utilisation les plus courants et nécessite un référentiel, un chemin de fichier et le contenu du texte. Si le chemin du fichier n'existe pas dans un référentiel, le composant crée tous les dossiers requis.
```
new SourceFile(repository, `path/to/my/file/in/repo/file.txt`, 'my file contents');
```
**Note**
Si vous écrivez deux fichiers au même emplacement dans le même référentiel, l'implémentation la plus récente remplace la précédente. Vous pouvez utiliser cette fonctionnalité pour superposer le code généré, et elle est particulièrement utile pour étendre le code que les plans personnalisés ont pu générer.
## Ajouter un fichier générique
Vous pouvez écrire des bits arbitraires dans votre dépôt. Vous pouvez lire à partir d'une mémoire tampon et utiliser la `File` construction.
```
new File(repository, `path/to/my/file/in/repo/file.img`, new Buffer(...));
new File(repository, `path/to/my/file/in/repo/new-img.img`, new StaticAsset('path/to/image.png').content());
```
## Copier des fichiers
Vous pouvez commencer avec le code généré en copiant et en collant le code de démarrage, puis en générant du code supplémentaire au-dessus de cette base. Placez le code dans le `static-assets` répertoire, puis ciblez ce code avec la `StaticAsset` construction. Dans ce cas, le chemin commence toujours à la racine du `static-assets` répertoire.
```
const starterCode = new StaticAsset('path/to/file/file.txt')
const starterCodeText = new StaticAsset('path/to/file/file.txt').toString()
const starterCodeRawContent = new StaticAsset('path/to/image/hello.png').content()
const starterCodePath = new StaticAsset('path/to/image/hello.png').path()
// starterCodePath is equal to 'path/to/image/hello.png'
```
Une sous-classe de `StaticAsset` is`SubstitutionAsset`. La sous-classe fonctionne exactement de la même manière, mais vous pouvez plutôt exécuter une substitution par moustache sur le fichier. Cela peut être utile pour générer des copy-and-replace styles.
La substitution d'actifs statiques utilise un moteur de création de modèles à moustache pour afficher les fichiers statiques qui sont ensemencés dans le référentiel source généré. Les règles de modélisation des moustaches sont appliquées lors du rendu, ce qui signifie que toutes les valeurs sont codées en HTML par défaut. Pour afficher du code HTML non filtré, utilisez la syntaxe à triple moustache. `{{{name}}}` Pour plus d'informations, consultez les règles relatives à la modélisation des [moustaches.](https://github.com/janl/mustache.js?tab=readme-ov-file#variables)
**Note**
L'exécution d'un substitut sur des fichiers qui ne sont pas interprétables par du texte peut générer des erreurs.
```
const starterCodeText = new SubstitionAsset('path/to/file/file.txt').subsitite({
'my_variable': 'subbed value1',
'another_variable': 'subbed value2'
})
```
## Cibler plusieurs fichiers
Les actifs statiques prennent en charge le ciblage global grâce à une fonction statique appelée `StaticAsset` et à ses sous-classes appelées`findAll(...)`, qui renvoie une liste d'actifs statiques préchargés avec leurs chemins, leur contenu, etc. Vous pouvez enchaîner la liste avec des `File` constructions pour copier et coller le contenu dans le `static-assets` répertoire.
```
new File(repository, `path/to/my/file/in/repo/file.img`, new Buffer(...));
new File(repository, `path/to/my/file/in/repo/new-img.img`, new StaticAsset('path/to/image.png').content());
```
## Création d'un nouveau dépôt et ajout de fichiers
Vous pouvez utiliser un composant de référentiel pour créer un nouveau référentiel dans un projet généré. Vous pouvez ensuite ajouter des fichiers ou des flux de travail au référentiel créé.
```
import { SourceRepository } from '@amazon-codecatalyst/codecatalyst-source-repositories';
...
const repository = new SourceRepository(this, { title: 'myRepo' });
```
L'exemple suivant montre comment ajouter des fichiers et des flux de travail à un référentiel existant :
```
import { SourceFile } from '@amazon-codecatalyst/codecatalyst-source-repositories';
import { Workflow } from '@amazon-codecatalyst/codecatalyst-workflows';
...
new SourceFile(repository, 'README.md', 'This is the content of my readme');
new Workflow(this, repository, {/**...workflowDefinition...**/});
```
La combinaison des deux éléments de code génère un référentiel unique nommé `myRepo` avec un fichier source `README.md` et un CodeCatalyst flux de travail à la racine.
# Ajouter des composants de flux de travail à un plan
Un flux de travail est utilisé par les CodeCatalyst projets Amazon pour exécuter des actions basées sur des déclencheurs. Vous pouvez utiliser des composants de flux de travail pour créer et assembler des fichiers YAML de flux de travail. Pour de plus amples informations, veuillez consulter [Définition du flux de travail YAML](workflow-reference.md).
**Pour importer des composants de flux de travail Amazon CodeCatalyst Blueprints**
Dans votre `blueprint.ts` fichier, ajoutez les éléments suivants :
```
import { WorkflowBuilder, Workflow } from '@amazon-codecatalyst/codecatalyst-workflows'
```
**Topics**
+ [Exemples de composants de flux de travail](#comp-workflows-examples-bp)
+ [Connexion à un environnement](#comp-workflows-connect-env-bp)
## Exemples de composants de flux de travail
### WorkflowBuilder composant
Vous pouvez utiliser une classe pour créer une définition de flux de travail. La définition peut être donnée à un composant de flux de travail pour le rendu dans un référentiel.
```
import { WorkflowBuilder } from '@amazon-codecatalyst/codecatalyst-workflows'
const workflowBuilder = new WorkflowBuilder({} as Blueprint, {
Name: 'my_workflow',
});
// trigger the workflow on pushes to branch 'main'
workflowBuilder.addBranchTrigger(['main']);
// add a build action
workflowBuilder.addBuildAction({
// give the action a name
actionName: 'build_and_do_some_other_stuff',
// the action pulls from source code
input: {
Sources: ['WorkflowSource'],
},
// the output attempts to autodiscover test reports, but not in the node modules
output: {
AutoDiscoverReports: {
Enabled: true,
ReportNamePrefix: AutoDiscovered,
IncludePaths: ['**/*'],
ExcludePaths: ['*/node_modules/**/*'],
},
},
// execute some arbitrary steps
steps: [
'npm install',
'npm run myscript',
'echo hello-world',
],
// add an account connection to the workflow
environment: convertToWorkflowEnvironment(myEnv),
});
```
### Composant du projet Workflow
L'exemple suivant montre comment un composant Projen peut être utilisé pour écrire un flux de travail YAML dans un référentiel :
```
import { Workflow } from '@amazon-codecatalyst/codecatalyst-workflows'
...
const repo = new SourceRepository
const blueprint = this;
const workflowDef = workflowBuilder.getDefinition()
// creates a workflow.yaml at .aws/workflows/${workflowDef.name}.yaml
new Workflow(blueprint, repo, workflowDef);
// can also pass in any object and have it rendered as a yaml. This is unsafe and may not produce a valid workflow
new Workflow(blueprint, repo, {... some object ...});
```
## Connexion à un environnement
De nombreux flux de travail doivent être exécutés via une connexion à un compte AWS. Les flux de travail gèrent cela en autorisant les actions à se connecter à des environnements avec des spécifications de nom de compte et de rôle.
```
import { convertToWorkflowEnvironment } from '@amazon-codecatalyst/codecatalyst-workflows'
const myEnv = new Environment(...);
// can be passed into a workflow constructor
const workflowEnvironment = convertToWorkflowEnvironment(myEnv);
// add a build action
workflowBuilder.addBuildAction({
...
// add an account connection to the workflow
environment: convertToWorkflowEnvironment(myEnv),
});
```
# Ajouter des composants d'environnements de développement à un plan
Les environnements de développement gérés (MDE) sont utilisés pour créer et installer des espaces de travail MDE dans. CodeCatalyst Le composant génère un `devfile.yaml` fichier. Pour plus d'informations, consultez [Introduction à Devfile](https://redhat-developer.github.io/devfile/) et[Modification d'un fichier de développement d'un référentiel pour un environnement de développement](devenvironment-devfile-moving.md).
```
new Workspace(this, repository, SampleWorkspaces.default);
```
**Pour importer des composants d'espaces de travail Amazon CodeCatalyst Blueprints**
Dans votre `blueprint.ts` fichier, ajoutez les éléments suivants :
```
import {...} from '@amazon-codecatalyst/codecatalyst-workspaces'
```
# Ajouter des composants relatifs aux problèmes à un plan
Dans CodeCatalyst, vous pouvez surveiller les fonctionnalités, les tâches, les bogues et tout autre travail impliqué dans votre projet. Chaque œuvre est conservée dans un dossier distinct appelé numéro. Chaque problème peut avoir une description, un responsable, un statut et d'autres propriétés que vous pouvez rechercher, regrouper et filtrer. Vous pouvez consulter vos problèmes à l'aide des vues par défaut ou créer vos propres vues avec un filtrage, un tri ou un regroupement personnalisés. Pour plus d'informations sur les concepts liés aux problèmes, consultez [Concepts des problèmes](issues-concepts.md) et[Quotas pour les numéros parus dans CodeCatalyst](issues-quotas.md).
Le composant issue génère une représentation JSON d'un problème. Le composant prend en entrée un champ ID et une définition du problème.
**Pour importer des CodeCatalyst plans Amazon, émet des composants**
Dans votre `blueprint.ts` fichier, ajoutez les éléments suivants :
```
import {...} from '@amazon-codecatalyst/blueprint-component.issues'
```
**Topics**
+ [Exemples de composants de problèmes](#comp-issues-examples-bp)
## Exemples de composants de problèmes
### Création d'un problème
```
import { Issue } from '@amazon-codecatalyst/blueprint-component.issues';
...
new Issue(this, 'myFirstIssue', {
title: 'myFirstIssue',
content: 'This is an example issue.',
});
```
### Création d'un problème hautement prioritaire
```
import { Workflow } from '@amazon-codecatalyst/codecatalyst-workflows'
...
const repo = new SourceRepository
const blueprint = this;
const workflowDef = workflowBuilder.getDefinition()
// Creates a workflow.yaml at .aws/workflows/${workflowDef.name}.yaml
new Workflow(blueprint, repo, workflowDef);
// Can also pass in any object and have it rendered as a yaml. This is unsafe and may not produce a valid workflow
new Workflow(blueprint, repo, {... some object ...});
```
### Création d'un problème peu prioritaire avec les étiquettes
```
import { Issue } from '@amazon-codecatalyst/blueprint-component.issues';
...
new Issue(this, 'myThirdIssue', {
title: 'myThirdIssue',
content: 'This is an example of a low priority issue with a label.',
priority: 'LOW',
labels: ['exampleLabel'],
});
```
# Utilisation de l'outillage Blueprint et de la CLI
La [CLI Blueprint](https://www.npmjs.com/package/@amazon-codecatalyst/blueprint-util.cli) fournit des outils pour gérer et utiliser vos plans personnalisés.
**Topics**
+ [Utilisation de l'outillage Blueprint](#working-with-bp-cli)
+ [Outil de téléchargement d'images](#image-upload-tool)
## Utilisation de l'outillage Blueprint
**Pour travailler avec les outils du plan**
1. Ouvrez la CodeCatalyst console à l'[adresse https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Reprenez votre environnement de développement. Pour de plus amples informations, veuillez consulter [Reprise d'un environnement de développement](devenvironment-resume.md).
Si vous n'avez pas d'environnement de développement, vous devez d'abord en créer un. Pour de plus amples informations, veuillez consulter [Création d’un environnement de développement](devenvironment-create.md).
1. Dans un terminal fonctionnel, exécutez la commande suivante pour installer la CLI Blueprint :
```
npm install -g @amazon-codecatalyst/blueprint-util.cli
```
1. Dans le `blueprint.ts` fichier, importez les outils que vous souhaitez utiliser au format suivant :
```
import { } from '@amazon-codecatalyst/blueprint-util.cli/lib//;
```
**Astuce**
Vous pouvez accéder au [https://github.com/aws/codecatalyst-blueprints/tree/main/packages/utils/blueprint-cli](https://github.com/aws/codecatalyst-blueprints/tree/main/packages/utils/blueprint-cli)pour trouver le nom de l'outillage que vous souhaitez utiliser.
**Si vous souhaitez utiliser l'outil de téléchargement d'images, ajoutez ce qui suit à votre script :**
```
import { uploadImagePublicly } from '@amazon-codecatalyst/blueprint-util.cli/lib/image-upload-tool/upload-image-to-aws';
```
**Exemples**
+ **Si vous souhaitez utiliser la fonction de publication, ajoutez ce qui suit à votre script :**
```
import { publish } from '@amazon-codecatalyst/blueprint-util.cli/lib/publish/publish';
```
+ **Si vous souhaitez utiliser l'outil de téléchargement d'images, ajoutez ce qui suit à votre script :**
```
import { uploadImagePublicly } from '@amazon-codecatalyst/blueprint-util.cli/lib/image-upload-tool/upload-image-to-aws';
```
1. Appelez la fonction.
**Exemples :**
+ **Si vous souhaitez utiliser la fonction de publication, ajoutez ce qui suit à votre script :**
```
await publish(logger, config.publishEndpoint, {});
```
+ **Si vous souhaitez utiliser l'outil de téléchargement d'images, ajoutez ce qui suit à votre script :**
```
const {imageUrl, imageName} = await uploadImagePublicly(logger, 'path/to/image'));
```
## Outil de téléchargement d'images
L'outil de téléchargement d'images vous permet de télécharger votre propre image dans un compartiment S3 de votre compte AWS, puis de diffuser cette image publiquement derrière CloudFront. L'outil prend un chemin d'image dans le stockage local (et un nom de compartiment facultatif) comme entrée, et renvoie l'URL de l'image accessible au public. Pour plus d'informations, consultez [Qu'est-ce qu'Amazon CloudFront ?](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Introduction.html) et [qu'est-ce qu'Amazon S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html)
**Pour utiliser l'outil de téléchargement d'images**
1. Clonez le [ GitHub référentiel de plans open source](https://github.com/aws/codecatalyst-blueprints) qui donne accès au SDK de plans et à des exemples de plans. Dans un terminal fonctionnel, exécutez la commande suivante :
```
git clone https://github.com/aws/codecatalyst-blueprints.git
```
1. Exécutez la commande suivante pour accéder au GitHub référentiel de plans :
```
cd codecatalyst-blueprints
```
1. Exécutez la commande suivante pour installer les dépendances :
```
yarn && yarn build
```
1. Exécutez la commande suivante pour vous assurer que la dernière version de Blueprint CLI est installée :
```
yarn upgrade @amazon-codecatalyst/blueprint-util.cli
```
1. Connectez-vous au compte AWS avec le compartiment S3 dans lequel vous souhaitez télécharger votre image. Pour plus d'informations, consultez [Configurer l'interface de ligne de commande AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) et [connectez-vous via l'interface de ligne de commande AWS](https://docs.aws.amazon.com/signin/latest/userguide/command-line-sign-in.html).
1. Exécutez la commande suivante depuis la racine de votre CodeCatalyst dépôt pour accéder au répertoire avec la CLI Blueprint :
```
cd packages/utils/blueprint-cli
```
1. Exécutez la commande suivante pour télécharger votre image dans un compartiment S3 :
```
yarn blueprint upload-image-public <./path/to/your/image>
```
Une URL vers votre image est générée. L'URL ne sera pas disponible immédiatement car le déploiement de la CloudFront distribution nécessite un certain temps. Vérifiez l'état de distribution pour connaître le dernier statut de déploiement. Pour plus d'informations, consultez la section [Utilisation des distributions](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-working-with.html).
# Évaluation des modifications de l'interface à l'aide de tests instantanés
Les tests instantanés générés sur plusieurs configurations de votre plan sont pris en charge.
Les plans permettent de [tester des instantanés](https://jestjs.io/docs/snapshot-testing) sur les configurations que vous avez fournies en tant qu'auteur du plan. Les configurations sont des remplacements partiels qui sont fusionnés au-dessus du fichier defaults.json à la racine d'un plan. Lorsque le test instantané est activé et configuré, le processus de création et de test synthétise les configurations données et vérifie que les sorties synthétisées n'ont pas changé par rapport à l'instantané de référence. Pour consulter le code de test des instantanés, consultez le [ GitHub référentiel de CodeCatalyst plans](https://github.com/aws/codecatalyst-blueprints/blob/main/packages/utils/projen-blueprint/src/test-snapshot.ts#L12).
**Pour activer les tests instantanés**
1. Dans le `.projenrc.ts` fichier, mettez à jour l'objet d'entrée ProjenBlueprint avec les fichiers que vous souhaitez capturer. Par exemple :
```
{
....
blueprintSnapshotConfiguration: {
snapshotGlobs: ['**', '!environments/**', '!aws-account-to-environment/**'],
},
}
```
1. Resynthétisez le plan pour créer des TypeScript fichiers dans votre projet de plan. Ne modifiez pas les fichiers source car ils sont gérés et régénérés par Projen. Utilisez la commande suivante :
```
yarn projen
```
1. Accédez au `src/snapshot-configurations` répertoire pour afficher le `default-config.json` fichier contenant un objet vide. Mettez à jour ou remplacez le fichier par une ou plusieurs de vos propres configurations de test. Chaque configuration de test est ensuite fusionnée avec le `defaults.json` fichier du projet, synthétisée et comparée aux instantanés lors des tests. Utilisez la commande suivante pour tester :
```
yarn test
```
La première fois que vous utilisez une commande de test, le message suivant s'affiche : `Snapshot Summary › NN snapshots written from 1 test suite` Les tests suivants vérifient que la sortie synthétisée n'a pas changé par rapport aux instantanés et affichent le message suivant : `Snapshots: NN passed, NN total`
Si vous modifiez intentionnellement votre plan pour produire une sortie différente, exécutez la commande suivante pour mettre à jour les instantanés de référence :
```
yarn test:update
```
Les instantanés s'attendent à ce que les sorties synthétisées soient constantes entre chaque exécution. Si votre plan génère des fichiers qui varient, vous devez exclure ces fichiers du test des instantanés. Mettez à jour l'`blueprintSnapshotConfiguration`objet de votre objet `ProjenBluerpint` d'entrée pour ajouter la `snapshotGlobs` propriété. La `snapshotGlobs` propriété est un tableau de [globs](https://github.com/isaacs/node-glob#glob-primer) qui détermine quels fichiers sont inclus ou exclus de la capture instantanée.
**Note**
Il existe une liste de globs par défaut. Si vous spécifiez votre propre liste, vous devrez peut-être rétablir explicitement les entrées par défaut.