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.
# El trabajo del autor de esquemas con la administración del ciclo de vida
La administración del ciclo de vida le permite mantener sincronizados un gran número de proyectos a partir de una única fuente común de prácticas recomendadas. Esto escala la propagación de las correcciones y el mantenimiento de cualquier número de proyectos en todo el ciclo de vida del desarrollo de software. La administración del ciclo de vida optimiza las campañas internas, las correcciones de seguridad, las auditorías, las actualizaciones en tiempo de ejecución, los cambios en las prácticas recomendadas y otros procedimientos de mantenimiento, ya que esos estándares se definen en un solo lugar y se actualizan automáticamente y de forma centralizada al publicar nuevos estándares.
Cuando se publica una nueva versión de un esquema, se les pide a todos los proyectos que contengan dicho esquema que se actualicen a la versión más reciente. El autor de un esquema también puede ver la versión de un esquema concreto contenido en un proyecto, a fin de garantizar el cumplimiento. Cuando hay conflictos en un repositorio de código fuente existente, la administración del ciclo de vida crea solicitudes de extracción. En el caso de los demás recursos, como el entorno de desarrollo, las actualizaciones de la administración del ciclo de vida solo crean nuevos recursos. Los usuarios pueden combinar o no esas solicitudes de extracción. Cuando se combinan las solicitudes de extracción pendientes, se actualiza la versión del esquema empleado en el proyecto, lo que incluye las opciones. Para obtener más información sobre cómo puede trabajar un usuario de esquemas con la administración del ciclo de vida, consulte [Uso de la administración del ciclo de vida en los proyectos existentes](lifecycle-management-user.md#using-lm-existing-projects) y [Uso de la administración del ciclo de vida en varios esquemas dentro de un proyecto](lifecycle-management-user.md#using-lm-multiple-bp).
**Topics**
+ [Pruebas de la administración del ciclo de vida mediante salidas de paquetes y conflictos de combinación](test-lm.md)
+ [Uso de estrategias de combinación para generar agrupaciones y especificar archivos](merge-strategies-lm.md)
+ [Acceso a los objetos de contexto para obtener detalles del proyecto](context-objects-lm.md)
# Pruebas de la administración del ciclo de vida mediante salidas de paquetes y conflictos de combinación
Puede probar localmente la administración del ciclo de vida la resolución de conflictos de combinación de su esquema. Se genera una serie de paquetes en el directorio `synth/` que representan las distintas fases de una actualización del ciclo de vida. Para probar la administración del ciclo de vida, puede ejecutar el siguiente comando yarn en su esquema: `yarn blueprint: resynth`. Para obtener más información sobre la resíntesis y los paquetes, consulte [Resíntesis](custom-bp-concepts.md#resynthesis-concept) y [Generación de archivos con resíntesis](merge-strategies-lm.md#three-way-merge-lm).
# Uso de estrategias de combinación para generar agrupaciones y especificar archivos
Puede utilizar estrategias de combinación para generar agrupaciones con resíntesis y especificar archivos para la actualización de la administración del ciclo de vida de los esquemas personalizados. Gracias a las estrategias de resíntesis y combinación, puede administrar las actualizaciones y controlar qué archivos se actualizan durante las implementaciones. También puede diseñar sus propias estrategias para controlar cómo se combinan los cambios en los proyectos de CodeCatalyst actuales.
**Topics**
+ [Generación de archivos con resíntesis](#three-way-merge-lm)
+ [Uso de estrategias de combinación](#vended-merge-strategies-lm)
+ [Especificación de archivos para las actualizaciones de la administración del ciclo de vida](#specify-files-lm-updates)
+ [Escritura de estrategias de combinación](#write-merge-strategies-lm)
## Generación de archivos con resíntesis
La resíntesis puede combinar el código fuente generado por un esquema con el código fuente generado previamente por el mismo esquema, de modo que los cambios en el esquema se propaguen a los proyectos actuales. Las combinaciones se ejecutan desde la función `resynth()` en todas las agrupaciones de salida de un esquema. En primer lugar, la resíntesis genera tres agrupaciones, que representan diferentes aspectos del estado del proyecto y del esquema. Se puede ejecutar manualmente de forma local con el comando `yarn blueprint:resynth`, lo que creará las agrupaciones si aún no existen. El trabajo manual con las agrupaciones le permitirá simular y probar el comportamiento de la resíntesis de manera local. De forma predeterminada, los esquemas solo ejecutan la resíntesis en los repositorios que se encuentran bajo `src/*`, ya que, normalmente, esa parte de la agrupación es la única bajo el control del código fuente. Para obtener más información, consulte [Resíntesis](custom-bp-concepts.md#resynthesis-concept).
+ `existing-bundle`: esta agrupación es una representación del estado del proyecto existente. El recurso de computación de la síntesis construye artificialmente esta agrupación para darle al esquema un contexto sobre el contenido del proyecto en el que se va a implementar (en caso de que haya contenido). Si ya hay algo en esta ubicación al ejecutar la resíntesis localmente, se restablecerá y se tratará como una simulación. De lo contrario, se ajustará al contenido de la `ancestor-bundle`.
+ `ancestor-bundle`: la agrupación que representa la salida del esquema si se ha sintetizado con algunas opciones o versiones anteriores. Si es la primera vez que se añade este esquema a un proyecto, no hay ningún antecesor, por lo que se configurará con el mismo contenido que el `existing-bundle`. En el ámbito local, si esta agrupación ya existe en esta ubicación, se tratará como una simulación.
+ `proposed-bundle`: la agrupación que simula la salida del esquema si se ha sintetizado con algunas opciones o versiones nuevas. Es la misma agrupación que generaría la función `synth()`. En el ámbito local, esta agrupación siempre se anula.
Todas las agrupaciones se crean durante una fase de resíntesis a la que se puede acceder desde la clase de esquema bajo `this.context.resynthesisPhase`.
+ `resolved-bundle`- la agrupación final, que es una representación de lo que se empaqueta e implementa en un proyecto de CodeCatalyst; puede ver qué archivos y diferencias se envían a los mecanismos de implementación. Es la salida de la función `resynth()`, que resuelve las combinaciones entre las otras tres agrupaciones.
La combinación triple se aplica tomando la diferencia entre la `ancestor-bundle` y la `proposed-bundle`, y sumando eso a la `existing-bundle` para generar la `resolved-bundle`. Todas las estrategias de combinación resuelven archivos en la `resolved-bundle`. La resíntesis resuelve el alcance de estas agrupaciones con las estrategias de combinación del esquema durante `resynth()`, y genera la agrupación resuelta a partir del resultado.
## Uso de estrategias de combinación
Puede utilizar una estrategia de combinación ofrecida por la biblioteca de esquemas. Estas estrategias proporcionan formas de resolver las salidas de archivos, así como los conflictos relacionados con archivos mencionados en la sección [Generación de archivos con resíntesis](#three-way-merge-lm).
+ `alwaysUpdate`: una estrategia que siempre se resuelve en el archivo propuesto.
+ `neverUpdate`: una estrategia que siempre se resuelve en el archivo existente.
+ `onlyAdd`: una estrategia que se resuelve en el archivo propuesto cuando aún no existe un archivo existente; de lo contrario, se resuelve en el archivo existente.
+ `threeWayMerge`: una estrategia que lleva a cabo una combinación triple entre los archivos existentes, los propuestos y los antecesores comunes. El archivo resuelto puede contener marcadores de conflicto si los archivos no se pueden combinar de forma limpia. El contenido de los archivos proporcionados debe estar codificado en UTF-8 para que la estrategia produzca resultados significativos. La estrategia intenta detectar si los archivos de entrada son binarios. Si la estrategia detecta un conflicto de combinación en un archivo binario, siempre devuelve el archivo propuesto.
+ `preferProposed`: una estrategia que lleva a cabo una combinación triple entre los archivos existentes, los propuestos y los antecesores comunes. Esta estrategia resuelve los conflictos seleccionando el lado del archivo propuesto en cada conflicto.
+ `preferExisting`: una estrategia que lleva a cabo una combinación triple entre los archivos existentes, los propuestos y los antecesores comunes. Esta estrategia resuelve los conflictos seleccionando el lado del archivo existente en cada conflicto.
Para ver el código fuente de las estrategias de combinación, consulte el [repositorio de código abierto en GitHub](https://github.com/aws/codecatalyst-blueprints/blob/main/packages/blueprints/blueprint/src/resynthesis/merge-strategies/merge-strategies.ts#L17).
## Especificación de archivos para las actualizaciones de la administración del ciclo de vida
Durante la resíntesis, los esquemas controlan cómo se combinan los cambios en un repositorio de código fuente existente. Sin embargo, es posible que no desee enviar actualizaciones a todos los archivos de un esquema. Por ejemplo, el código de muestra, como las hojas de estilo CSS, está creado para que sea específico para un proyecto. La estrategia de combinación triple es la opción predeterminada si no especifica otra estrategia. Mediante la determinación de estrategias de combinación en el constructo del repositorio, los esquemas pueden especificar qué archivos son de su propiedad y cuáles no. Los esquemas pueden actualizar las estrategias de combinación, y las estrategias más recientes se pueden utilizar durante la resíntesis.
```
const sourceRepo = new SourceRepository(this, {
title: 'my-repo',
});
sourceRepo.setResynthStrategies([
{
identifier: 'dont-override-sample-code',
description: 'This strategy is applied accross all sample code. The blueprint will create sample code, but skip attempting to update it.',
strategy: MergeStrategies.neverUpdate,
globs: [
'**/src/**',
'**/css/**',
],
},
]);
```
Se pueden especificar varias estrategias de combinación y la última estrategia es la que tiene prioridad. Los archivos descubiertos utilizan de forma predeterminada una combinación triple similar a Git. Mediante el constructo de `MergeStrategies` se proporcionan varias estrategias de combinación, pero puede escribir las suyas. Las estrategias proporcionadas se adhieren al controlador de [estrategias de combinación de Git](https://git-scm.com/docs/merge-strategies).
## Escritura de estrategias de combinación
Además de utilizar una de las estrategias de construcción y combinación proporcionadas, también puede escribir sus propias estrategias. Las estrategias deben adherirse a una interfaz de estrategia estándar. Debe escribir una función de estrategias que tome versiones de un archivo desde la `existing-bundle`, la `proposed-bundle` y la `ancestor-bundle` y las combine en un único archivo resuelto. Por ejemplo:
```
type StrategyFunction = (
/**
* file from the ancestor bundle (if it exists)
*/
commonAncestorFile: ContextFile | undefined,
/**
* file from the existing bundle (if it exists)
*/
existingFile: ContextFile | undefined,
/**
* file from the proposed bundle (if it exists)
*/
proposedFile: ContextFile | undefined,
options?: {})
/**
* Return: file you'd like in the resolved bundle
* passing undefined will delete the file from the resolved bundle
*/
=> ContextFile | undefined;
```
Si no hay archivos (o no están definidos), la ruta del archivo no existirá en la agrupación de esa ubicación en particular.
**Ejemplo**:
```
strategies: [
{
identifier: 'dont-override-sample-code',
description: 'This strategy is applied across all sample code. The blueprint will create sample code, but skip attempting to update it.',
strategy: (ancestor, existing, proposed) => {
const resolvedfile = ...
...
// do something
...
return resolvedfile
},
globs: [
'**/src/**',
'**/css/**',
],
},
],
```
# Acceso a los objetos de contexto para obtener detalles del proyecto
Como autor de un esquema, puede acceder al contexto del proyecto del esquema durante la síntesis para obtener información como los nombres del espacio y de los proyectos, o los archivos existentes en el repositorio de código fuente de un proyecto. También puede obtener detalles como la fase de resíntesis que está generando el esquema. Por ejemplo, puede acceder al contexto para saber si va a resintetizar para generar un paquete antecesor o un paquete propuesto. Luego, puede usar el contexto de código existente para transformar el código en su repositorio. Por ejemplo, puede escribir su propia estrategia de resíntesis para establecer estándares de código específicos. La estrategia se puede añadir al archivo `blueprint.ts` para los esquemas pequeños o se puede crear un archivo independiente para las estrategias.
En el siguiente ejemplo se muestra cómo encontrar archivos en el contexto de un proyecto, configurar un generador de flujos de trabajo y establecer una estrategia de resíntesis basada en esquemas para un archivo concreto:
```
const contextFiles = this.context.project.src.findAll({
fileGlobs: ['**/package.json'],
});
// const workflows = this.context.project.src.findAll({
// fileGlobs: ['**/.codecatalyst/**.yaml'],
// });
const security = new WorkflowBuilder(this, {
Name: 'security-workflow',
});
new Workflow(this, repo, security.getDefinition());
repo.setResynthStrategies([
{
identifier: 'force-security',
globs: ['**/.codecatalyst/security-workflow.yaml'],
strategy: MergeStrategies.alwaysUpdate,
},
]);
for (const contextFile of contextFiles) {
const packageObject = JSON.parse(contextFile.buffer.toString());
new SourceFile(internalRepo, contextFile.path, JSON.stringify({
...packageObject,
}, null, 2));
}
}
```