Amazon ya no CodeCatalyst está abierto a nuevos clientes. Los clientes existentes pueden seguir utilizando el servicio con normalidad. Para obtener más información, consulte [Cómo migrar desde CodeCatalyst](migration.md). Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Desarrollo de un esquema personalizado para cumplir los requisitos del proyecto Antes de publicar un esquema personalizado, puede desarrollarlo para que cumpla requisitos específicos. Puede desarrollar su esquema personalizado y probarlo creando un proyecto durante la vista previa. Puede desarrollar el esquema personalizado para incluir los componentes del proyecto, como el código fuente específico, las conexiones de cuentas, los flujos de trabajo, las incidencias o cualquier otro componente que se pueda crear en CodeCatalyst. **importante** Si desea utilizar paquetes de esquemas de código fuente externo, tenga en cuenta los riesgos que podrían conllevar dichos paquetes. Los esquemas personalizados que añada en su espacio, así como el código que generen, quedan bajo su responsabilidad. **importante** Para añadir un esquema personalizado a su espacio de CodeCatalyst, debe iniciar sesión con una cuenta que tenga el rol **Administrador del espacio** o **Usuario avanzado** en el espacio. **Para desarrollar o actualizar un esquema personalizado** 1. Reanude el entorno de desarrollo. Para obtener más información, consulte [Reanudación de un entorno de desarrollo](devenvironment-resume.md). Si no dispone de un entorno de desarrollo, primero debe crear uno. Para obtener más información, consulte [Creación de un entorno de desarrollo](devenvironment-create.md). 1. Abra un terminal en su entorno de desarrollo. 1. Si optó por un flujo de trabajo de publicación al crear el esquema, la última versión del esquema se publicará automáticamente. Incorpore los cambios para asegurarse de que el archivo `package.json` tenga la versión incrementada. Utilice el siguiente comando: ``` git pull ``` 1. En el archivo `src/blueprint.ts`, edite las opciones del esquema personalizado. El asistente de CodeCatalyst interpreta la interfaz de `Options` de forma dinámica para generar una interfaz de usuario (UI) de selección. Puede desarrollar su esquema personalizado añadiendo componentes y etiquetas compatibles. Para obtener más información, consulte [Modificación de las características del esquema con un asistente de front-end](wizard-bp.md), [Adición de componentes del entorno a un esquema](comp-env-bp.md), [Cómo añadir componentes de regiones a un esquema](region-comp-bp.md), [Adición de componentes de repositorio y código fuente a un esquema](comp-repo-source-bp.md), [Adición de componentes de flujo de trabajo a un esquema](comp-workflow-bp.md) y [Adición de componentes de entornos de desarrollo a un esquema](comp-dev-env-bp.md). También puede ver el SDK de los esquemas y ejemplos de esquemas para obtener asistencia adicional a la hora de desarrollar su esquema personalizado. Para obtener más información, consulte el [repositorio de GitHub de código abierto](https://github.com/aws/codecatalyst-blueprints). Los esquemas personalizados proporcionan paquetes de vista previa como resultado de una síntesis realizada correctamente. El paquete del proyecto representa el código fuente, la configuración y los recursos de un proyecto, y las operaciones de la API de implementación de CodeCatalyst lo utilizan para implementarlo en un proyecto. Si desea seguir desarrollando su esquema personalizado, vuelva a ejecutar el proceso de síntesis del modelo. Para obtener más información, consulte [Proyectos de esquemas personalizados](custom-bp-concepts.md). # Modificación de las características del esquema con un asistente de front-end La interfaz `Options` del archivo `blueprint.ts` genera automáticamente un asistente de selección de esquemas en CodeCatalyst. El asistente de front-end es compatible con las modificaciones y características de las `Options` de un esquema mediante [comentarios y etiquetas de estilo JSDOC](https://jsdoc.app/about-getting-started.html). Puede utilizar comentarios y etiquetas de estilo JSDOC para realizar tareas. Por ejemplo, puede seleccionar el texto que se muestra encima de una opción, habilitar características como la validación de entradas o hacer que una opción se pueda contraer. El asistente funciona interpretando un árbol de sintaxis abstracta (AST) generado a partir del tipo TypeScript desde la interfaz `Options`. El asistente se configura automáticamente según el tipo descrito de la mejor manera posible. No todos los tipos son compatibles. Entre otros tipos compatibles se incluyen el selector de región y el selector de entorno. A continuación presentamos un ejemplo de un asistente que utiliza comentarios y etiquetas JSDOC con las `Options` del esquema: ``` 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[]; } ``` El nombre de visualización de cada opción de la interfaz `Options` aparece de forma predeterminada en `camelCase`. El texto sin formato del comentario de estilo JSDOC aparece como texto encima de la opción en el asistente. **Topics** + [Etiquetas compatibles](#supported-tags-bp) + [Tipos de TypeScript compatibles](#supported-typescript-bp) + [Comunicación con el usuario durante la síntesis](#communication-mid-synthesis) ## Etiquetas compatibles Las siguientes etiquetas JSDOC son compatibles con las `Options` de un esquema personalizado en el asistente de front-end. ### @inlinePolicy ./path/to/policy/file.json + **Requiere**: la opción debe ser de tipo `Role`. + **Uso**: le permite comunicar las políticas integradas que necesita un rol. Se espera que la ruta `policy.json` esté bajo el código fuente. Use esta etiqueta cuando necesite una política personalizada para un rol. + **Dependencias**: `blueprint-cli 0.1.12` y posteriores + **Ejemplo**: `@inlinePolicy ./deployment-policy.json` ``` environment: EnvironmentDefinition{ awsAccountConnection: AccountConnection{ /** * @inlinePolicy ./path/to/deployment-policy.json */ cdkRole: Role[]; }; }; ``` ### @trustPolicy ./path/to/policy/file.json + **Requiere**: la opción debe ser de tipo `Role`. + **Uso**: le permite comunicar las políticas de confianza que necesita un rol. Se espera que la ruta `policy.json` esté bajo el código fuente. Use esta etiqueta cuando necesite una política personalizada para un rol. + **Dependencias**: `blueprint-cli 0.1.12` y posteriores + **Ejemplo**: `@trustPolicy ./trust-policy.json` ``` environment: EnvironmentDefinition{ awsAccountConnection: AccountConnection{ /** * @trustPolicy ./path/to/trust-policy.json */ cdkRole: Role[]; }; }; ``` ### Expresión regular @validationRegex + **Requiere**: la opción debe ser una cadena. + **Uso**: realiza la validación de entrada de la opción mediante la expresión regular dada y muestra `@validationMessage`. + **Ejemplo**: `@validationRegex /^[a-zA-Z0-9_]+$/` + **Recomendación**: debe usarse con `@validationMessage`. El mensaje de validación está vacío de forma predeterminada. ### Cadena @validationMessage + **Requiere**: `@validationRegex` u otros errores para revisar el uso. + **Uso**: muestra un mensaje de validación en caso de error de `@validation*`. + **Ejemplo**: `@validationMessage Must contain only upper and lowercase letters, numbers, and underscores`. + **Recomendación**: debe usarse con `@validationMessage`. El mensaje de validación está vacío de forma predeterminada. ### Booleano @collapsed (opcional) + **Requiere**: N/A + **Uso**: booleano que permite hacer que una subopción se pueda contraer. Si la anotación contraída está presente, su valor predeterminado es true. Si se establece el valor en `@collapsed false`, se crea una sección contraíble que inicialmente está abierta. + **Ejemplo**: `@collapsed true` ### Cadena de caracteres @displayName + **Requiere**: N/A + **Uso**: cambia el nombre de visualización de la opción. Admite formatos distintos de camelCase para el nombre de visualización. + **Ejemplo**: `@displayName Blueprint Name` ### Cadena de caracteres @displayName + **Requiere**: N/A + **Uso**: cambia el nombre de visualización de la opción. Admite formatos distintos de [camelCase](https://en.wikipedia.org/wiki/Camel_case) para el nombre de visualización. + **Ejemplo**: `@displayName Blueprint Name` ### Número @defaultEntropy + **Requiere**: la opción debe ser una cadena. + **Uso**: agrega a la opción una cadena alfanumérica aleatoria de una longitud específica. + **Ejemplo**: `@defaultEntropy 5` ### Cadena @placeholder (opcional) + **Requiere**: N/A + **Uso**: cambia el marcador de posición del campo de texto predeterminado. + **Ejemplo**: `@placeholder type project name here` ### Número @textArea (opcional) + **Requiere**: N/A + **Uso**: convierte la entrada de cadena en un componente de área de texto para secciones de texto más grandes. Al añadir un número se define el número de filas. El valor predeterminado es de cinco filas. + **Ejemplo**: `@textArea 10` ### Booleano @hidden (opcional) + **Requiere**: N/A + **Uso**: oculta el archivo al usuario a menos que se produzca un error en la comprobación de validación. El valor predeterminado es true. + **Ejemplo**: `@hidden` ### Booleano @button (opcional) + **Requiere**: N/A + **Uso**: la anotación debe estar en una propiedad booleana. Agrega un botón que se sintetizará como true cuando se seleccione. No es un conmutador. + **Ejemplo**: `buttonExample: boolean;` ``` /** * @button */ buttonExample: boolean; ``` ### Booleano @showName (opcional) + **Requiere**: N/A + **Uso**: solo se puede usar en un tipo de conexión de cuenta. Muestra la entrada de nombre oculta. El valor predeterminado es `default_environment`. + **Ejemplo**: `@showName true` ``` /** * @showName true */ accountConnection: AccountConnection<{ ... }>; ``` ### Booleano @showEnvironmentType (opcional) + **Requiere**: N/A + **Uso**: solo se puede usar en un tipo de conexión de cuenta. Muestra el menú desplegable de tipos de entornos ocultos. Todas las conexiones se establecen de forma predeterminada en `production`. Las opciones son **Non-production** o **Production**. + **Ejemplo**: `@showEnvironmentType true` ``` /** * @showEnvironmentType true */ accountConnection: AccountConnection<{ ... }>; ``` ### Booleano @forceDefault (opcional) + **Requiere**: N/A + **Uso**: utiliza el valor predeterminado proporcionado por el autor del esquema en lugar del valor que utilizaba anteriormente el usuario. + **Ejemplo**: `forceDeafultExample: any;` ``` /** * @forceDefault */ forceDeafultExample: any; ``` ### blueprintName @requires + **Requiere**: anota la interfaz `Options`. + **Uso**: advierte al usuario que agregue el `blueprintName` especificado al proyecto como requisito para el esquema actual. + **Ejemplo**: `@requires '@amazon-codecatalyst/blueprints.blueprint-builder'` ``` /* * @requires '@amazon-codecatalyst/blueprints.blueprint-builder' */ export interface Options extends ParentOptions { ... ``` ### Expresión regular @filter + **Requiere**: anota la interfaz `Selector` o `MultiSelect`. + **Uso**: filtra el menú desplegable del asistente según las opciones que coincidan con la expresión regular especificada. + **Ejemplo**: `@filter /blueprintPackageName/` ``` /** * @filter /myPackageName/ */ blueprintInstantiation?: Selector; ... ``` ## Tipos de TypeScript compatibles Los siguientes tipos de TypeScript son compatibles con las `Options` de un esquema personalizado en el asistente de front-end. ### Número + **Requiere**: la opción debe ser de tipo `number`. + **Uso**: genera un campo de entrada numérico. + **Ejemplo**: `age: number` ``` { age: number ... } ``` ### Cadena + **Requiere**: la opción debe ser de tipo `string`. + **Uso**: genera un campo de entrada de cadena. + **Ejemplo**: `name: string` ``` { age: string ... } ``` ### Lista de cadenas + **Requiere**: la opción debe ser una matriz de tipo `string`. + **Uso**: genera una entrada de lista de cadenas. + **Ejemplo**: `isProduction: boolean` ``` { isProduction: boolean ... } ``` ### Casillla de verificación + **Requiere**: la opción debe ser un `boolean`. + **Uso**: genera una casilla de verificación. + **Ejemplo**: `isProduction: boolean` ``` { isProduction: boolean ... } ``` ### Botón de opción + **Requiere**: la opción de ser una unión de tres cadenas o menos. + **Uso**: genera un botón de opción seleccionado. **nota** Cuando hay cuatro o más elementos, este tipo se representa como un menú desplegable. + **Ejemplo**: `color: 'red' | 'blue' | 'green'` ``` { color: 'red' | 'blue' | 'green' ... } ``` ### Dropdown + **Requiere**: la opción de ser una unión de cuatro cadenas o más. + **Uso**: genera un menú desplegable. + **Ejemplo**: `runtimes: 'nodejs' | 'python' | 'java' | 'dotnetcore' | 'ruby'` ``` { runtimes: 'nodejs' | 'python' | 'java' | 'dotnetcore' | 'ruby' ... } ``` ### Sección ampliable + **Requiere**: la opción debe ser un objeto. + **Uso**: genera una sección ampliable. Las opciones del objeto se anidarán dentro de la sección ampliable del asistente. + **Ejemplo**: ``` { expandableSectionTitle: { nestedString: string; nestedNumber: number; } } ``` ### Tupla + **Requiere**: la opción debe ser de tipo `Tuple`. + **Uso**: genera una entrada de par clave-valor. + **Ejemplo**: `tuple: Tuple[string, string]>` ``` { tuple: Tuple[string, string]>; ... } ``` ### Lista de tuplas + **Requiere**: la opción debe ser una matriz de tipo `Tuple`. + **Uso**: genera una entrada de lista de tuplas. + **Ejemplo**: `tupleList: Tuple[string, string]>[]` ``` { tupleList: Tuple[string, string]>[]; ... } ``` ### Selector + **Requiere**: la opción debe ser de tipo `Selector`. + **Uso**: genera un menú desplegable con los repositorios de código fuente o los esquemas aplicados a un proyecto. + **Ejemplo**: `sourceRepo: Selector` ``` { sourceRepo: Selector; sourceRepoOrAdd: Selector; blueprintInstantiation: Selector; ... } ``` ### Selección múltiple + **Requiere**: la opción debe ser de tipo `Selector`. + **Uso**: genera una entrada de selección múltiple. + **Ejemplo**: `multiselect: MultiSelect['A' | 'B' | 'C' | 'D' | 'E']>` ``` { multiselect: MultiSelect['A' | 'B' | 'C' | 'D' | 'E']>; ... } ``` ## Comunicación con el usuario durante la síntesis En calidad de autor de un esquema, puede comunicarse con los usuarios más allá de los mensajes de validación. Por ejemplo, un miembro del espacio podría ver una combinación de opciones que genere un esquema que no esté claro. Los esquemas personalizados permiten comunicar los mensajes de error a los usuarios mediante la invocación de la síntesis. El esquema de base implementa una función `throwSynthesisError(...)` que espera un mensaje de error claro. Puede invocar el mensaje mediante lo siguiente: ``` //blueprint.ts this.throwSynthesisError({ name: BlueprintSynthesisErrorTypes.BlueprintSynthesisError, message: 'hello from the blueprint! This is a custom error communicated to the user.' }) ``` # Generación de entradas y representación de elementos del asistente front-end Puede generar entradas del asistente con DynamicKVInput y crear dinámicamente elementos del asistente front-end para su esquema personalizado. **Topics** + [Creación de entornos de desarrollo](#dynamickvinput-bp) + [Creación dinámica de elementos del asistente](#create-wizard-elements-bp) ## Creación de entornos de desarrollo El tipo DynamicKVInput se puede usar para generar entradas del asistente front-end utilizando los valores predeterminados del esquema personalizado. Para ver el esquema más actualizado, consulte la [definición de DynamicKVInput](https://github.com/aws/codecatalyst-blueprints/blob/main/packages/blueprints/blueprint/src/ui-selectors/dynamic-kv-input.ts). En el siguiente ejemplo se muestra cómo usar `Options` para conformar un objeto: ``` import { DynamicKVInput } from '@amazon-codecatalyst/blueprints.blueprint'; export interface Options extends ParentOptions { parameters: DynamicKVInput[]; } ``` En el siguiente ejemplo se muestra cómo se pueden establecer parámetros predeterminados con varias propiedades: ``` { "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." } ] } ``` ## Creación dinámica de elementos del asistente Se puede utilizar el mismo esquema que se utiliza para crear las entradas del asistente para volver a representar dinámicamente un asistente durante la síntesis. Este asistente se puede utilizar para responder a las preguntas de seguimiento de un usuario cuando sea necesario. ``` //blueprint.ts export interface Options extends ParentOptions { ... dynamicOptions: OptionsSchemaDefinition<'optionsIdentifier', KVSchema>; } ``` Después, se puede configurar el asistente durante el período de síntesis mediante el uso de un componente `Options`. ``` 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." } ]); ``` # Adición de componentes del entorno a un esquema El asistente de esquemas personalizados se genera dinámicamente desde la interfaz `Options` expuesta a través del asistente. Los esquemas permiten generar componentes de la interfaz de usuario (IU) a partir de tipos expuestos. **Importación de componentes del entorno de esquemas de Amazon CodeCatalyst** Añada lo siguiente al archivo `blueprint.ts`: ``` import {...} from '@amazon-codecatalyst/codecatalyst-environments' ``` **Topics** + [Creación de entornos de desarrollo](#create-dev-env-bp) + [Lista de entornos](#list-env-bp) + [Ejemplos de interfaces simuladas](#examples-comp-env-bp) ## Creación de entornos de desarrollo En el siguiente ejemplo se muestra cómo implementar la aplicación en la nube: ``` export interface Options extends ParentOptions { ... myNewEnvironment: EnvironmentDefinition{ thisIsMyFirstAccountConnection: AccountConnection{ thisIsARole: Role['lambda', 's3', 'dynamo']; }; }; } ``` La interfaz genera un componente de la interfaz de usuario que solicita un nuevo entorno (`myNewEnvironment`) con una conexión de cuenta única (`thisIsMyFirstAccountConnection`). También se genera un rol en la conexión de cuenta (`thisIsARole`) con `['lambda', 's3', 'dynamo']` como las funcionalidades de rol mínimas requeridas. No todos los usuarios tienen conexiones de cuenta, por lo que debería comprobar cuándo un usuario no se conecta a una cuenta o no se conecta a una cuenta con un rol. Los roles también se pueden anotar con `@inlinePolicies`. Para obtener más información, consulte [@inlinePolicy ./path/to/policy/file.json](wizard-bp.md#inline-policy-tag). El componente de entorno requiere un `name` y `environmentType`. El siguiente código es la forma predeterminada mínima requerida: ``` { ... "myNewEnvironment": { "name": "myProductionEnvironment", "environmentType": "PRODUCTION" }, } ``` A continuación, el componente de la interfaz de usuario le solicitará varios campos. A medida que rellene los campos, el esquema irá adquiriendo una forma totalmente expandida. Puede resultarle útil incluir el esquema simulado completo del archivo `defaults.json` para fines de prueba y desarrollo. ## Lista de entornos Al especificar un tipo de matriz `EnvironmentDefinition` se generará una lista de entornos en la interfaz de usuario del asistente. ``` export interface Options extends ParentOptions { ... /** @showName readOnly */ myEnvironments: EnvironmentDefinition<{ thisIsMyFirstAccountConnection: AccountConnection<{ thisIsARole: Role<['lambda', 's3', 'dynamo']>; }>; }>[]; } ``` En el siguiente ejemplo se muestran los valores predeterminados para una lista de entornos: ``` { ... "myEnvironments": [ { "name": "myProductionEnvironment", "environmentType": "PRODUCTION" }, { "name": "myDevelopmentEnvironment", "environmentType": "DEVELOPMENT" }, ] } ``` ## Ejemplos de interfaces simuladas ### Interfaz simulada 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" ] } } } } ``` ### Interfaz simulada compleja ``` 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']; }; }; } ``` ### Interfaz simulada completa ``` { ... "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" ] } } }, } ``` # Adición de componentes de secretos a un esquema Los secretos se pueden usar en CodeCatalyst para almacenar datos confidenciales a los que se puede hacer referencia en los flujos de trabajo. Puede añadir un secreto a su esquema personalizado y hacer referencia a él en su flujo de trabajo. Para obtener más información, consulte [Enmascaramiento de datos mediante secretos](workflows-secrets.md). **Importación del tipo de región de los esquemas de Amazon CodeCatalyst** Añada lo siguiente al archivo `blueprint.ts`: ``` import { Secret, SecretDefinition } from '@amazon-codecatalyst/blueprint-component.secrets' ``` **Topics** + [Creación de un secreto](#comp-create-secrets-bp) + [Referencia a un secreto en un flujo de trabajo](#comp-reference-secrets-bp) ## Creación de un secreto El siguiente ejemplo crea un componente de IU que solicita al usuario que introduzca un valor de secreto y una descripción opcional: ``` export interface Options extends ParentOptions { ... mySecret: SecretDefinition; } export class Blueprint extends ParentBlueprint { constructor(options_: Options) { new Secret(this, options.secret); } ``` El componente secreto requiere un `name`. El siguiente código es la forma predeterminada mínima requerida: ``` { ... "secret": { "name": "secretName" }, } ``` ## Referencia a un secreto en un flujo de trabajo En el siguiente esquema de ejemplo, se crea un secreto y un flujo de trabajo que hace referencia al valor del secreto. Para obtener más información, consulte [Referencia a un secreto en un flujo de trabajo](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(), ); } ``` Para obtener más información sobre el uso de secretos en CodeCatalyst, consulte [Enmascaramiento de datos mediante secretos](workflows-secrets.md). # Cómo añadir componentes de regiones a un esquema El tipo de región se puede agregar a la interfaz `Options` de su esquema personalizado para generar un componente; en el asistente de esquema puede especificar una o más regiones de AWS. El tipo de región se puede importar desde el esquema base al archivo `blueprint.ts`. Para obtener más información, consulte [Regiones de AWS](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/). **Para importar los CodeCatalyst blueprints de Amazon, escriba la región** Añada lo siguiente al archivo `blueprint.ts`: ``` import { Region } from '@amazon-codecatalyst/blueprints.blueprint' ``` El parámetro de tipo de región es una matriz de códigos de región de AWS entre los que puede elegir, o puede utilizar `*` para incluir todas las regiones de AWS compatibles. **Topics** + [Anotaciones](#region-annotations-bp) + [Ejemplos de componentes de regiones](#region-components-examples) ## Anotaciones JSDoc se pueden añadir etiquetas a cada campo de la `Options` interfaz para personalizar el aspecto y el comportamiento de un campo en el asistente. Para el tipo de región, se admiten las siguientes etiquetas: + La anotación `@displayName` se puede utilizar para cambiar la etiqueta del campo en el asistente. Ejemplo: `@displayName AWS Region` + La anotación `@placeholder` se puede utilizar para cambiar el marcador de posición del componente de selección o selección múltiple. Ejemplo: `@placeholder Choose AWS Region` ## Ejemplos de componentes de regiones ### Selección de una región de una lista especificada ``` export interface Options extends ParentOptions { ... /** * @displayName Region */ region: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>; } ``` ### Selección de una o más regiones de una lista especificada ``` export interface Options extends ParentOptions { ... /** * @displayName Regions */ multiRegion: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>[]; } ``` ### Selección de una región de AWS ``` export interface Options extends ParentOptions { ... /** * @displayName Region */ region: Region<['*']>; } ``` ### Selección de una o más regiones de una lista especificada ``` export interface Options extends ParentOptions { ... /** * @displayName Regions */ multiRegion: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>[]; } ``` # Adición de componentes de repositorio y código fuente a un esquema Amazon CodeCatalyst utiliza un repositorio para almacenar el código. El repositorio toma un nombre como entrada. La mayoría de los componentes se almacenan en un repositorio, como los archivos de código fuente, los flujos de trabajo y otros componentes, como los entornos de desarrollo administrados (MDE). El componente de repositorio de código fuente también exporta los componentes que se utilizan para administrar archivos y activos estáticos. Los repositorios tienen restricciones de nomenclatura. Para obtener más información, consulte [Almacene código y colabore en él con los repositorios de código fuente en CodeCatalystAlmacenamiento de código y colaboración con los repositorios de código fuente](source.md). ``` const repository = new SourceRepository(this, { title: 'my-new-repository-title', }); ``` **Importación de componentes del código fuente y repositorio de esquemas de Amazon CodeCatalyst** Añada lo siguiente al archivo `blueprint.ts`: ``` import {...} from '@caws-blueprint-component/caws-source-repositories' ``` **Topics** + [Adición de un archivo](#repo-add-file-bp) + [Adición de un archivo genérico](#repo-add-generic-file-bp) + [Copia de archivos](#repo-copy-file-bp) + [Establecimiento del destino de varios archivos](#target-multiple-files-bp) + [Creación de un nuevo repositorio e incorporación de archivos](#repo-code-examples-bp) ## Adición de un archivo Puede escribir un archivo de texto en un repositorio con el constructo `SourceFile`. La operación es uno de los casos de uso más comunes y requiere un repositorio, una ruta de archivo y contenido de texto. Si la ruta del archivo no existe en un repositorio, el componente crea todas las carpetas necesarias. ``` new SourceFile(repository, `path/to/my/file/in/repo/file.txt`, 'my file contents'); ``` **nota** Si escribe dos archivos en la misma ubicación dentro del mismo repositorio, la implementación más reciente sobrescribe la anterior. Puede utilizar la característica para superponer el código generado, que es especialmente útil para ampliar el código que puedan haber generado los esquemas personalizados. ## Adición de un archivo genérico Puede escribir bits arbitrarios en su repositorio. Puede leer de un búfer y usar el constructo `File`. ``` 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()); ``` ## Copia de archivos Puede empezar con el código generado copiando y pegando el código inicial y, a continuación, generando más código a partir de ahí. Coloque el código dentro del directorio `static-assets` y, a continuación, defina el destino del código con el constructo `StaticAsset`. En este caso, la ruta siempre comienza en la raíz del directorio `static-assets`. ``` 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' ``` Una subclase de `StaticAsset` es `SubstitutionAsset`. La subclase funciona exactamente igual, pero permite realizar una sustitución de mustache en el archivo. Esto puede resultar útil para generar contenido con el método de copiar y reemplazar. La sustitución de activos estáticos utiliza un motor de plantillas de mustache para representar los archivos estáticos que se incluyen en el repositorio de código fuente generado. Las reglas de creación de plantillas de mustache se aplican durante la representación, lo que significa que todos los valores están codificados en HTML de forma predeterminada. Para representar HTML sin secuencias de escape, utilice la sintaxis de mustache triple `{{{name}}}`. Para obtener más información, consulte las [reglas de creación de plantillas de mustache](https://github.com/janl/mustache.js?tab=readme-ov-file#variables). **nota** Si se ejecuta una sustitución en archivos que no son interpretables como texto, se pueden producir errores. ``` const starterCodeText = new SubstitionAsset('path/to/file/file.txt').subsitite({ 'my_variable': 'subbed value1', 'another_variable': 'subbed value2' }) ``` ## Establecimiento del destino de varios archivos Los activos estáticos admiten destinos glob mediante una función estática en `StaticAsset` y sus subclases llamadas `findAll(...)`, que devuelve una lista de los activos estáticos previamente cargados con sus rutas, contenido, etc. Puede encadenar la lista con construcciones `File` para copiar y pegar el contenido en el directorio `static-assets`. ``` 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()); ``` ## Creación de un nuevo repositorio e incorporación de archivos Puede usar un componente de repositorio para crear un repositorio nuevo en un proyecto generado. A continuación, puede añadir archivos o flujos de trabajo al repositorio creado. ``` import { SourceRepository } from '@amazon-codecatalyst/codecatalyst-source-repositories'; ... const repository = new SourceRepository(this, { title: 'myRepo' }); ``` En el siguiente ejemplo se muestra cómo añadir archivos y flujos de trabajo a un repositorio existente: ``` 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 combinación de los dos fragmentos de código genera un único repositorio denominado `myRepo` con un archivo de código fuente `README.md` y un flujo de trabajo de CodeCatalyst en la raíz. # Adición de componentes de flujo de trabajo a un esquema Los proyectos de Amazon CodeCatalyst utilizan un flujo de trabajo para ejecutar acciones basadas en desencadenadores. Puede usar los componentes del flujo de trabajo para crear y componer archivos YAML del flujo de trabajo. Para obtener más información, consulte [Definición de flujo de trabajo en YAML](workflow-reference.md). **Importación de componentes de flujo de trabajo de esquemas de Amazon CodeCatalyst** Añada lo siguiente al archivo `blueprint.ts`: ``` import { WorkflowBuilder, Workflow } from '@amazon-codecatalyst/codecatalyst-workflows' ``` **Topics** + [Ejemplos de componentes de flujo de trabajo](#comp-workflows-examples-bp) + [Conexión a un entorno](#comp-workflows-connect-env-bp) ## Ejemplos de componentes de flujo de trabajo ### Componente de WorkflowBuilder Puede usar una clase para crear una definición de flujo de trabajo. La definición se puede asignar a un componente del flujo de trabajo para representarlo en un repositorio. ``` 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), }); ``` ### Componente de flujo de trabajo Projen El siguiente ejemplo muestra cómo se puede usar un componente de Projen para escribir un flujo de trabajo de YAML en un repositorio: ``` 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 ...}); ``` ## Conexión a un entorno Muchos flujos de trabajo deben ejecutarse en una conexión de cuenta de AWS. Los flujos de trabajo se encargan de ello al permitir que las acciones se conecten a entornos con especificaciones de nombre de cuenta y rol. ``` 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), }); ``` # Adición de componentes de entornos de desarrollo a un esquema Los entornos de desarrollo administrados (MDE) se utilizan para crear y mantener espacios de trabajo de MDE en CodeCatalyst. El componente genera un archivo `devfile.yaml`. Para obtener más información, consulte [Introduction to Devfile](https://redhat-developer.github.io/devfile/) y [Edición de un devfile de repositorio para un entorno de desarrollo](devenvironment-devfile-moving.md). ``` new Workspace(this, repository, SampleWorkspaces.default); ``` **Importación de componentes de espacios de trabajo de esquemas de Amazon CodeCatalyst** Añada lo siguiente al archivo `blueprint.ts`: ``` import {...} from '@amazon-codecatalyst/codecatalyst-workspaces' ``` # Adición de componentes de incidencias a un esquema En CodeCatalyst, puede supervisar las características, las tareas, los errores y cualquier otro trabajo relacionado con su proyecto. Cada trabajo se guarda en un registro distinto denominado “incidencia”. Cada incidencia puede tener una descripción, un responsable, un estado y otras propiedades, que puede buscar, agrupar y filtrar. Puede ver sus incidencias con las vistas predeterminadas o puede crear las suyas propias con filtros, clasificaciones o agrupaciones personalizados. Para obtener más información sobre los conceptos relacionados con las incidencias, consulte [Conceptos sobre problemas](issues-concepts.md) y [Cuotas para emisiones en CodeCatalyst](issues-quotas.md). El componente de incidencias genera una representación JSON de una incidencia. El componente incluye un campo de ID y una definición de la incidencia como entrada. **Importación de componentes de incidencias de esquemas de Amazon CodeCatalyst** Añada lo siguiente al archivo `blueprint.ts`: ``` import {...} from '@amazon-codecatalyst/blueprint-component.issues' ``` **Topics** + [Ejemplos de componentes de incidencias](#comp-issues-examples-bp) ## Ejemplos de componentes de incidencias ### Creación de una incidencia ``` import { Issue } from '@amazon-codecatalyst/blueprint-component.issues'; ... new Issue(this, 'myFirstIssue', { title: 'myFirstIssue', content: 'This is an example issue.', }); ``` ### Creación de una incidencia de alta prioridad ``` 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 ...}); ``` ### Creación de una incidencia de baja prioridad con etiquetas ``` 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'], }); ``` # Uso de herramientas y CLI de esquemas La [CLI de esquemas](https://www.npmjs.com/package/@amazon-codecatalyst/blueprint-util.cli) proporciona herramientas para administrar los esquemas personalizados y trabajar con ellos. **Topics** + [Uso de herramientas de esquemas](#working-with-bp-cli) + [Herramienta de carga de imágenes](#image-upload-tool) ## Uso de herramientas de esquemas **Uso de las herramientas de esquemas** 1. Abra la consola de CodeCatalyst en [https://codecatalyst.aws/](https://codecatalyst.aws/). 1. Reanude el entorno de desarrollo. Para obtener más información, consulte [Reanudación de un entorno de desarrollo](devenvironment-resume.md). Si no dispone de un entorno de desarrollo, primero debe crear uno. Para obtener más información, consulte [Creación de un entorno de desarrollo](devenvironment-create.md). 1. En un terminal que funcione, ejecute el siguiente comando para instalar la CLI de esquemas: ``` npm install -g @amazon-codecatalyst/blueprint-util.cli ``` 1. En el archivo `blueprint.ts`, importe las herramientas que desee utilizar en el siguiente formato: ``` import { } from '@amazon-codecatalyst/blueprint-util.cli/lib//; ``` **sugerencia** Puede ir al [https://github.com/aws/codecatalyst-blueprints/tree/main/packages/utils/blueprint-cli](https://github.com/aws/codecatalyst-blueprints/tree/main/packages/utils/blueprint-cli) para buscar el nombre de la herramienta que desea utilizar. **Si desea utilizar la herramienta de carga de imágenes, añada lo siguiente al script:** ``` import { uploadImagePublicly } from '@amazon-codecatalyst/blueprint-util.cli/lib/image-upload-tool/upload-image-to-aws'; ``` **Ejemplos** + **Si desea utilizar la función de publicación, añada lo siguiente al script:** ``` import { publish } from '@amazon-codecatalyst/blueprint-util.cli/lib/publish/publish'; ``` + **Si desea utilizar la herramienta de carga de imágenes, añada lo siguiente al script:** ``` import { uploadImagePublicly } from '@amazon-codecatalyst/blueprint-util.cli/lib/image-upload-tool/upload-image-to-aws'; ``` 1. Llame a la función. **Ejemplos de:** + **Si desea utilizar la función de publicación, añada lo siguiente al script:** ``` await publish(logger, config.publishEndpoint, {}); ``` + **Si desea utilizar la herramienta de carga de imágenes, añada lo siguiente al script:** ``` const {imageUrl, imageName} = await uploadImagePublicly(logger, 'path/to/image')); ``` ## Herramienta de carga de imágenes La herramienta de carga de imágenes le permite cargar su propia imagen en un bucket de S3 de su cuenta de AWS y, a continuación, distribuirla públicamente en CloudFront. La herramienta toma como entrada una ruta de imagen en el almacenamiento local (y el nombre del bucket opcional) y devuelve la URL de la imagen que está disponible públicamente. Para obtener más información, consulte [¿Qué es Amazon CloudFront?](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Introduction.html) y [¿Qué es Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) **Uso de la herramienta de carga de imágenes** 1. Clone el [repositorio GitHub de esquemas de código abierto](https://github.com/aws/codecatalyst-blueprints) que proporciona acceso al SDK de esquemas y a los esquemas de ejemplo. En un terminal que funcione, ejecute el siguiente comando: ``` git clone https://github.com/aws/codecatalyst-blueprints.git ``` 1. Ejecute el siguiente comando para acceder al repositorio de GitHub de esquemas: ``` cd codecatalyst-blueprints ``` 1. Ejecute el siguiente comando para instalar las dependencias: ``` yarn && yarn build ``` 1. Ejecute el siguiente comando para asegurarse de que esté instalada la última versión de la CLI de esquemas: ``` yarn upgrade @amazon-codecatalyst/blueprint-util.cli ``` 1. Inicie sesión en la cuenta de AWS con el bucket de S3 en el que desea cargar la imagen. Para obtener más información[, consulte Configure the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) y [Sign in through the AWS Command Line Interface](https://docs.aws.amazon.com/signin/latest/userguide/command-line-sign-in.html). 1. Ejecute el siguiente comando desde la raíz de su repositorio de CodeCatalyst para acceder al directorio con la CLI de esquemas: ``` cd packages/utils/blueprint-cli ``` 1. Ejecute el siguiente comando para cargar la imagen en un bucket de S3: ``` yarn blueprint upload-image-public <./path/to/your/image> ``` Se generará una URL para la imagen. La URL no estará disponible de forma inmediata, ya que la distribución de CloudFront requiere algún tiempo para implementarse. Compruebe el estado de la distribución para obtener el estado más reciente de la implementación. Para obtener más información, consulte [Working with distributions](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-working-with.html). # Evaluación de los cambios en la interfaz con pruebas de instantáneas Las pruebas de instantáneas generadas en diversas configuraciones de su esquema son compatibles. Los esquemas permiten realizar [pruebas de instantáneas](https://jestjs.io/docs/snapshot-testing) en las configuraciones que usted haya proporcionado como autor del esquema. Las configuraciones son anulaciones parciales que se combinan sobre el archivo defaults.json, en la raíz de un esquema. Cuando las pruebas de instantáneas están habilitadas y configuradas, el proceso de compilación y prueba sintetiza las configuraciones dadas y verifica que los resultados sintetizados no hayan cambiado con respecto a la instantánea de referencia. Para ver el código de prueba de instantáneas, consulte el [repositorio de GitHub de esquemas de CodeCatalyst](https://github.com/aws/codecatalyst-blueprints/blob/main/packages/utils/projen-blueprint/src/test-snapshot.ts#L12). **Habilitación de las pruebas de instantáneas** 1. En el archivo `.projenrc.ts`, actualice el objeto de entrada a ProjenBlueprint con los archivos de los que desee realizar una instantánea. Por ejemplo: ``` { .... blueprintSnapshotConfiguration: { snapshotGlobs: ['**', '!environments/**', '!aws-account-to-environment/**'], }, } ``` 1. Vuelva a sintetizar el esquema para crear archivos TypeScript en su proyecto de esquema. No edite los archivos de origen, ya que Projen los mantiene y los regenera. Utilice el siguiente comando: ``` yarn projen ``` 1. Vaya hasta el directorio `src/snapshot-configurations` para ver el archivo `default-config.json` con un objeto vacío. Actualice o sustituya el archivo por una o más de sus propias configuraciones de prueba. A continuación, cada configuración de prueba se combina con el archivo `defaults.json` del proyecto, se sintetiza y se compara con las instantáneas durante las pruebas. Use el siguiente comando para las pruebas: ``` yarn test ``` La primera vez que utilice un comando de prueba, aparecerá el siguiente mensaje: `Snapshot Summary › NN snapshots written from 1 test suite`. Las pruebas posteriores verifican que la salida sintetizada no haya cambiado con respecto a las instantáneas y muestran el siguiente mensaje: `Snapshots: NN passed, NN total`. Si cambia el esquema de forma intencionada para producir un resultado diferente, ejecute el siguiente comando para actualizar las instantáneas de referencia: ``` yarn test:update ``` Las instantáneas esperan que los resultados sintetizados sean constantes entre cada ejecución. Si el esquema genera archivos que varían, debe excluirlos de las pruebas de instantáneas. Actualice el objeto `blueprintSnapshotConfiguration` del objeto de entrada `ProjenBluerpint` para añadir la propiedad `snapshotGlobs`. La propiedad `snapshotGlobs` es una matriz de [globs](https://github.com/isaacs/node-glob#glob-primer) que determina qué archivos se incluyen o excluyen de las instantáneas. **nota** Existe una lista de globs predeterminada. Si especifica su propia lista, es posible que tenga que recuperar de forma explícita las entradas predeterminadas.