Amazon non CodeCatalyst è più aperta a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [Come migrare da CodeCatalyst](migration.md).

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Sviluppo di un modello personalizzato per soddisfare i requisiti del progetto
<a name="develop-bp"></a>

Prima di pubblicare un blueprint personalizzato, puoi svilupparlo per soddisfare requisiti specifici. Puoi sviluppare il tuo blueprint personalizzato e testarlo creando un progetto durante l'anteprima. È possibile sviluppare il blueprint personalizzato per includere componenti del progetto, come codice sorgente specifico, connessioni di account, flussi di lavoro, problemi o qualsiasi altro componente che può essere creato in. CodeCatalyst

**Importante**  
Se desideri utilizzare pacchetti blueprint provenienti da fonti esterne, considera i rischi che possono derivare da tali pacchetti. Sei responsabile dei blueprint personalizzati che aggiungi al tuo spazio e del codice che generano.

**Importante**  
Per sviluppare un blueprint personalizzato nel tuo CodeCatalyst spazio, devi accedere con un account che abbia il ruolo di **amministratore dello spazio** o **Power user** nello spazio.

**Per sviluppare o aggiornare un blueprint personalizzato**

1. Riprendi il tuo ambiente di sviluppo. Per ulteriori informazioni, consulta [Ripresa del lavoro in un ambiente di sviluppo](devenvironment-resume.md).

   Se non disponi di un ambiente di sviluppo, devi prima crearne uno. Per ulteriori informazioni, consulta [Creazione di un ambiente di sviluppo](devenvironment-create.md).

1. Apri un terminale funzionante nel tuo ambiente di sviluppo.

1. Se hai scelto un flusso di lavoro di rilascio durante la creazione del blueprint, la versione più recente del blueprint viene pubblicata automaticamente. Estraete le modifiche per assicurarvi che il `package.json` file abbia la versione incrementata. Utilizza il seguente comando :

   ```
   git pull
   ```

1. Nel `src/blueprint.ts` file, modifica le opzioni del tuo blueprint personalizzato. L'`Options`interfaccia viene interpretata dalla CodeCatalyst procedura guidata in modo dinamico per generare un'interfaccia utente di selezione (UI). È possibile sviluppare un blueprint personalizzato aggiungendo componenti e tag supportati. Per ulteriori informazioni, consultare [Modifica delle funzionalità del blueprint con una procedura guidata di front-end](wizard-bp.md), [Aggiungere componenti di ambiente a un blueprint](comp-env-bp.md), [Aggiungere componenti regionali a un blueprint](region-comp-bp.md), [Aggiungere componenti del repository e del codice sorgente a un blueprint](comp-repo-source-bp.md), [Aggiungere componenti del flusso di lavoro a un blueprint](comp-workflow-bp.md) e [Aggiungere componenti Dev Environments a un blueprint](comp-dev-env-bp.md).

   Puoi anche visualizzare l'SDK dei blueprint e i blueprint di esempio per ricevere ulteriore assistenza durante lo sviluppo del tuo blueprint personalizzato. [Per ulteriori informazioni, consulta il repository open source. GitHub ](https://github.com/aws/codecatalyst-blueprints)

I blueprint personalizzati forniscono pacchetti di anteprima come risultato di una sintesi riuscita. Il pacchetto del progetto rappresenta il codice sorgente, la configurazione e le risorse di un progetto e viene utilizzato dalle operazioni API di CodeCatalyst distribuzione per la distribuzione in un progetto. Se desideri continuare a sviluppare il tuo blueprint personalizzato, esegui nuovamente il processo di sintesi del blueprint. Per ulteriori informazioni, consulta [Concetti di progetti personalizzati](custom-bp-concepts.md).

# Modifica delle funzionalità del blueprint con una procedura guidata di front-end
<a name="wizard-bp"></a>

Una procedura guidata di selezione del blueprint attiva CodeCatalyst viene generata automaticamente dall'`Options`interfaccia nel file. `blueprint.ts` [La procedura guidata front-end supporta le modifiche e le funzionalità di un blueprint utilizzando commenti e tag in stile JSDOC. `Options`](https://jsdoc.app/about-getting-started.html) È possibile utilizzare commenti e tag in stile JSDOC per eseguire attività. Ad esempio, puoi selezionare il testo visualizzato sopra un'opzione, abilitare funzionalità come la convalida dell'input o rendere un'opzione comprimibile. La procedura guidata funziona interpretando un albero di sintassi astratto (AST) generato dal tipo dell' TypeScript interfaccia. `Options` La procedura guidata si configura automaticamente nel miglior modo possibile nel tipo descritto. Non tutti i tipi sono supportati. Altri tipi supportati includono il selettore di regione e il selettore di ambiente.

Di seguito è riportato un esempio di procedura guidata che utilizza commenti e tag JSDOC con blueprint: `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[];
}
```

Per impostazione predefinita, il nome visualizzato di ciascuna opzione dell'`Options`interfaccia viene visualizzato in. `camelCase` Il testo normale nel commento in stile JSDOC viene visualizzato come testo sopra l'opzione nella procedura guidata.

**Topics**
+ [Tag supportati](#supported-tags-bp)
+ [TypeScript Tipi supportati](#supported-typescript-bp)
+ [Comunicare con l'utente durante la sintesi](#communication-mid-synthesis)

## Tag supportati
<a name="supported-tags-bp"></a>

I seguenti tag JSDOC sono supportati da un blueprint personalizzato `Options` nella procedura guidata di front-end.

### @inlinePolicy. /path/to/policy/file.json
<a name="inline-policy-tag"></a>
+ **Richiede**: opzione per essere un tipo. `Role`
+ **Utilizzo**: consente di comunicare le politiche in linea necessarie per un ruolo. Il `policy.json` percorso dovrebbe essere in codice sorgente. Usa questo tag quando hai bisogno di una politica personalizzata per un ruolo.
+ **Dipendenze** - `blueprint-cli 0.1.12` e oltre
+ **Esempio** - `@inlinePolicy ./deployment-policy.json`

```
environment: EnvironmentDefinition{
    awsAccountConnection: AccountConnection{
      /**
       * @inlinePolicy ./path/to/deployment-policy.json
       */
      cdkRole: Role[];
    };
   };
```

### @trustPolicy. /path/to/policy/file.json
<a name="trust-policy-tag"></a>
+ **Richiede**: opzione per essere un tipo. `Role`
+ **Utilizzo**: consente di comunicare le politiche di fiducia necessarie per un ruolo. Il `policy.json` percorso dovrebbe essere in codice sorgente. Usa questo tag quando hai bisogno di una politica personalizzata per un ruolo.
+ **Dipendenze** - `blueprint-cli 0.1.12` e oltre
+ **Esempio** - `@trustPolicy ./trust-policy.json`

```
environment: EnvironmentDefinition{
    awsAccountConnection: AccountConnection{
      /**
       * @trustPolicy ./path/to/trust-policy.json
       */
      cdkRole: Role[];
    };
   };
```

### Espressione Regex @validationRegex
<a name="validation-regex-tag"></a>
+ **Richiede** che l'opzione sia una stringa.
+ **Utilizzo**: esegue la convalida dell'input sull'opzione utilizzando l'espressione regex e i display specificati. `@validationMessage`
+ **Esempio -** `@validationRegex /^[a-zA-Z0-9_]+$/`
+ **Raccomandazione**: da utilizzare con`@validationMessage`. Per impostazione predefinita, il messaggio di convalida è vuoto.

### Stringa @validationMessage
<a name="validation-message-tag"></a>
+ **Richiede** - `@validationRegex` o altri errori per verificare l'utilizzo.
+ **Utilizzo**: visualizza un messaggio di convalida in `@validation*` caso di errore.
+ **Esempio** -`@validationMessage Must contain only upper and lowercase letters, numbers, and underscores`.
+ **Raccomandazione**: utilizzare con`@validationMessage`. Per impostazione predefinita, il messaggio di convalida è vuoto.

### @collapsed boolean (opzionale)
<a name="collapsed-boolean-tag"></a>
+ **Richiede**: N/A
+ **Utilizzo**: valore booleano che consente a una sottoopzione di essere comprimibile. Se l'annotazione compressa è presente, il suo valore predefinito è true. L'impostazione del valore su `@collapsed false` crea una sezione comprimibile inizialmente aperta.
+ **Esempio** - `@collapsed true`

### stringa @displayName
<a name="display-name-tag"></a>
+ **Richiede** - N/A
+ **Utilizzo**: modifica il nome visualizzato dell'opzione. Consente formati diversi da CamelCase per il nome visualizzato.
+ **Esempio -** `@displayName Blueprint Name`

### stringa @displayName
<a name="display-name-tag"></a>
+ **Richiede** - N/A
+ **Utilizzo**: modifica il nome visualizzato dell'opzione. Consente formati diversi da [CamelCase](https://en.wikipedia.org/wiki/Camel_case) per il nome visualizzato.
+ **Esempio -** `@displayName Blueprint Name`

### Numero @defaultEntropy
<a name="default-entropy-tag"></a>
+ **Richiede**: l'opzione deve essere una stringa.
+ **Utilizzo**: aggiunge all'opzione una stringa alfanumerica randomizzata di una lunghezza specificata.
+ **Esempio -** `@defaultEntropy 5`

### stringa @placeholder (opzionale)
<a name="placeholder-tag"></a>
+ **Richiede**: N/A
+ **Utilizzo**: modifica il segnaposto predefinito del campo di testo.
+ **Esempio -** `@placeholder type project name here`

### Numero @textArea (opzionale)
<a name="text-area-tag"></a>
+ **Richiede**: N/A
+ **Utilizzo**: converte la stringa immessa in un componente dell'area di testo per sezioni di testo più grandi. L'aggiunta di un numero definisce il numero di righe. L'impostazione predefinita è cinque righe.
+ **Esempio** - `@textArea 10`

### @hidden boolean (opzionale)
<a name="hidden-tag"></a>
+ **Richiede**: N/A
+ **Utilizzo**: nasconde il file all'utente a meno che il controllo di convalida non fallisca. Il valore predefinito è true.
+ **Esempio** - `@hidden`

### @button boolean (opzionale)
<a name="button-tag"></a>
+ **Richiede**: N/A
+ **Utilizzo: l'**annotazione deve trovarsi su una proprietà booleana. Aggiunge un pulsante che verrà sintetizzato come vero quando viene selezionato. Non è un interruttore.
+ **Esempio -** `buttonExample: boolean;`

  ```
  /**
    * @button
    */
  buttonExample: boolean;
  ```

### @showName boolean (opzionale)
<a name="show-name-tag"></a>
+ **Richiede**: N/A
+ **Utilizzo**: può essere utilizzato solo su un tipo di connessione a un account. Mostra l'immissione di un nome nascosto. L'impostazione predefinita è `default_environment`.
+ **Esempio** - `@showName true`

  ```
  /**
    * @showName true
    */
  accountConnection: AccountConnection<{
      ...
  }>;
  ```

### @ showEnvironmentType boolean (opzionale)
<a name="show-environment-tag"></a>
+ **Richiede**: N/A
+ **Utilizzo**: può essere utilizzato solo su un tipo di connessione a un account. Mostra il menu a discesa del tipo di ambiente nascosto. Tutte le connessioni sono predefinite su. `production` Le opzioni sono **Non produzione** o **Produzione**.
+ **Esempio** - `@showEnvironmentType true`

  ```
  /**
    * @showEnvironmentType true
    */
  accountConnection: AccountConnection<{
      ...
  }>;
  ```

### @forceDefault boolean (opzionale)
<a name="force-default-tag"></a>
+ **Richiede**: N/A
+ **Utilizzo**: utilizza il valore predefinito fornito dall'autore del blueprint anziché il valore utilizzato in precedenza dall'utente.
+ **Esempio** - `forceDeafultExample: any;`

  ```
  /**
    * @forceDefault
    */
  forceDeafultExample: any;
  ```

### @requires BlueprintName
<a name="requires-tag"></a>
+ **Richiede**: annota l'interfaccia. `Options`
+ **Utilizzo**: avvisa l'utente di aggiungere elementi specificati `blueprintName` al progetto come requisito per il blueprint corrente.
+ **Esempio -** `@requires '@amazon-codecatalyst/blueprints.blueprint-builder'`

  ```
  /*
   * @requires '@amazon-codecatalyst/blueprints.blueprint-builder'
   */
  export interface Options extends ParentOptions {
  ...
  ```

### Regex @filter
<a name="filter-regex-tag"></a>
+ **Richiede**: annota l'interfaccia `Selector` or`MultiSelect`.
+ **Utilizzo**: filtra il menu a discesa nella procedura guidata in base alle opzioni che corrispondono all'espressione regolare specificata.
+ **Esempio -** `@filter /blueprintPackageName/`

  ```
   /**
       * @filter /myPackageName/
       */
      blueprintInstantiation?: Selector<BlueprintInstantiation>;
  ...
  ```

## TypeScript Tipi supportati
<a name="supported-typescript-bp"></a>

I seguenti TypeScript tipi sono supportati da un blueprint personalizzato `Options` nella procedura guidata di front-end.

### Numero
<a name="number-ts-tag"></a>
+ **Richiede**: opzione per essere un tipo. `number`
+ **Utilizzo**: genera un campo di immissione numerico.
+ **Esempio** - `age: number`

```
{
  age: number
  ...
}
```

### Stringa
<a name="string-ts-tag"></a>
+ **Richiede**: l'opzione deve essere un tipo`string`.
+ **Utilizzo**: genera un campo di input di tipo stringa.
+ **Esempio** - `name: string`

```
{
  age: string
  ...
}
```

### Elenco stringhe
<a name="string-list-ts-tag"></a>
+ **Richiede**: l'opzione deve essere una matrice di tipo`string`.
+ **Utilizzo**: genera un input per un elenco di stringhe.
+ **Esempio** - `isProduction: boolean`

```
{
  isProduction: boolean
  ...
}
```

### Checkbox
<a name="checkbox-ts-tag"></a>
+ **Richiede**: opzione per essere un`boolean`.
+ **Utilizzo**: genera una casella di controllo.
+ **Esempio** - `isProduction: boolean`

```
{
  isProduction: boolean
  ...
}
```

### Radio
<a name="radio-ts-tag"></a>
+ **Richiede**: l'opzione deve essere un'unione di tre o meno stringhe.
+ **Utilizzo**: genera una radio selezionata.
**Nota**  
Quando ci sono quattro o più elementi, questo tipo viene visualizzato come un menu a discesa.
+ **Esempio -** `color: 'red' | 'blue' | 'green'`

```
{
  color: 'red' | 'blue' | 'green'
  ...
}
```

### Elenco a discesa
<a name="dropdown-ts-tag"></a>
+ **Richiede** - Opzione per essere un'unione di quattro o più stringhe.
+ **Utilizzo**: genera un menu a discesa.
+ **Esempio** - `runtimes: 'nodejs' | 'python' | 'java' | 'dotnetcore' | 'ruby'`

```
{
  runtimes: 'nodejs' | 'python' | 'java' | 'dotnetcore' | 'ruby'
  ...
}
```

### Sezione espandibile
<a name="expandable-ts-tag"></a>
+ **Richiede**: opzione per essere un oggetto.
+ **Utilizzo**: genera una sezione espandibile. Le opzioni dell'oggetto verranno annidate all'interno della sezione espandibile della procedura guidata.
+ **Esempio -** 

```
{
     expandableSectionTitle: {
         nestedString: string;
         nestedNumber: number;
     }
}
```

### Tupla
<a name="tuple-ts-tag"></a>
+ **Richiede**: l'opzione deve essere di tipo`Tuple`.
+ **Utilizzo**: genera un input a pagamento con valore chiave.
+ **Esempio -** `tuple: Tuple[string, string]>`

```
{
    tuple: Tuple[string, string]>;
    ...
}
```

### Elenco di tuple
<a name="tuple-list-ts-tag"></a>
+ **Richiede**: opzione per essere un array di tipo`Tuple`.
+ **Utilizzo**: genera un input per l'elenco delle tuple.
+ **Esempio** - `tupleList: Tuple[string, string]>[]`

```
{
  tupleList: Tuple[string, string]>[];
  ...
}
```

### Selector
<a name="selector-ts-tag"></a>
+ **Richiede**: l'opzione deve essere di tipo`Selector`.
+ **Utilizzo**: genera un elenco a discesa dei repository o dei blueprint di origine applicati a un progetto.
+ **Esempio -** `sourceRepo: Selector<SourceRepository>`

```
{
    sourceRepo: Selector<SourceRepository>;
    sourceRepoOrAdd: Selector<SourceRepository | string>;
    blueprintInstantiation: Selector<BlueprintInstantiation>;
  ...
}
```

### Selezione multipla
<a name="multiselect-ts-tag"></a>
+ **Richiede**: opzione per essere di tipo. `Selector`
+ **Utilizzo**: genera un input multiselezione.
+ **Esempio -** `multiselect: MultiSelect['A' | 'B' | 'C' | 'D' | 'E']>`

```
{
  multiselect: MultiSelect['A' | 'B' | 'C' | 'D' | 'E']>;
  ...
}
```

## Comunicare con l'utente durante la sintesi
<a name="communication-mid-synthesis"></a>

In qualità di autore del blueprint, puoi rispondere agli utenti oltre ai semplici messaggi di convalida. Ad esempio, un membro dello spazio potrebbe visualizzare una combinazione di opzioni che produce un blueprint non chiaro. I blueprint personalizzati supportano la capacità di comunicare messaggi di errore agli utenti richiamando la sintesi. Il blueprint di base implementa una `throwSynthesisError(...)` funzione che prevede un messaggio di errore chiaro. È possibile richiamare il messaggio utilizzando quanto segue:

```
//blueprint.ts
this.throwSynthesisError({
   name: BlueprintSynthesisErrorTypes.BlueprintSynthesisError,
   message: 'hello from the blueprint! This is a custom error communicated to the user.'
})
```

# Generazione di input e rirenderizzazione degli elementi della procedura guidata front-end
<a name="comp-dynamic-input-bp"></a>

Puoi generare input guidati con la procedura guidata dinamica e creare dinamicamente elementi della procedura guidata front-end per il tuo blueprint personalizzato. KVInput 

**Topics**
+ [Creazione di ambienti di sviluppo](#dynamickvinput-bp)
+ [Creazione dinamica di elementi della procedura guidata](#create-wizard-elements-bp)

## Creazione di ambienti di sviluppo
<a name="dynamickvinput-bp"></a>

Il KVInput tipo Dynamic può essere utilizzato per generare input guidati front-end utilizzando le impostazioni predefinite del bluerpint personalizzato. [Per visualizzare la maggior parte degli schemi, consulta la definizione dinamica. up-to-date KVInput ](https://github.com/aws/codecatalyst-blueprints/blob/main/packages/blueprints/blueprint/src/ui-selectors/dynamic-kv-input.ts)

L'esempio seguente mostra come è possibile utilizzare `Options` per modellare un oggetto:

```
import { DynamicKVInput } from '@amazon-codecatalyst/blueprints.blueprint';

export interface Options extends ParentOptions {

  parameters: DynamicKVInput[];

}
```

L'esempio seguente mostra come impostare i parametri predefiniti con diverse proprietà:

```
{ 
"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."
        }
    ]
}
```

## Creazione dinamica di elementi della procedura guidata
<a name="create-wizard-elements-bp"></a>

Lo stesso schema utilizzato per la creazione degli input della procedura guidata può essere utilizzato per rirenderizzare dinamicamente una procedura guidata durante la sintesi. Questo può essere usato per rispondere a domande di follow-up da parte di un utente quando necessario.

```
//blueprint.ts

export interface Options extends ParentOptions {
...
 dynamicOptions: OptionsSchemaDefinition<'optionsIdentifier', KVSchema>;
}
```

La procedura guidata può quindi essere impostata durante il periodo di sintesi utilizzando un `Options` componente.

```
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<KVSchema>(this, 'optionsIdentifier', [
    {
            "key": "SchedulerFrequency",
            "value": 5,
            "displayType": "number",
            "displayName": "Scheduler Frequency",
            "description": "Scheduler running frequency in minutes."
    }
   ]);
```

# Aggiungere componenti di ambiente a un blueprint
<a name="comp-env-bp"></a>

La procedura guidata per i progetti personalizzati viene generata dinamicamente dall'`Options`interfaccia esposta tramite la procedura guidata. I blueprint supportano la generazione di componenti dell'interfaccia utente (UI) a partire dai tipi esposti.

**Per importare i componenti dell'ambiente Amazon CodeCatalyst Blueprint**

Nel tuo `blueprint.ts` file, aggiungi quanto segue:

```
import {...} from '@amazon-codecatalyst/codecatalyst-environments'
```

**Topics**
+ [Creazione di ambienti di sviluppo](#create-dev-env-bp)
+ [Elenco degli ambienti](#list-env-bp)
+ [Esempi di interfacce fittizie](#examples-comp-env-bp)

## Creazione di ambienti di sviluppo
<a name="create-dev-env-bp"></a>

L'esempio seguente mostra come distribuire l'applicazione nel cloud:

```
export interface Options extends ParentOptions {
        ...
        myNewEnvironment:  EnvironmentDefinition{
            thisIsMyFirstAccountConnection: AccountConnection{
                thisIsARole: Role['lambda', 's3', 'dynamo'];
             };
        };
    }
```

L'interfaccia genera un componente dell'interfaccia utente che richiede un nuovo ambiente (`myNewEnvironment`) con una singola connessione a un account (`thisIsMyFirstAccountConnection`. Viene inoltre generato un ruolo sulla connessione dell'account (`thisIsARole`) con `['lambda', 's3', 'dynamo']` le funzionalità minime richieste per il ruolo. Non tutti gli utenti dispongono di connessioni all'account, quindi dovresti verificare se un utente non connette un account o non collega un account a un ruolo. I ruoli possono anche essere annotati con`@inlinePolicies`. Per ulteriori informazioni, consulta [@inlinePolicy. /path/to/policy/file.json](wizard-bp.md#inline-policy-tag).

Il componente ambientale richiede un comando `name` e`environmentType`. Il codice seguente è la forma predefinita minima richiesta:

```
{
  ...
  "myNewEnvironment": {
    "name": "myProductionEnvironment",
    "environmentType": "PRODUCTION"
  },
}
```

Il componente dell'interfaccia utente richiede quindi l'immissione di vari campi. Man mano che compili i campi, il progetto assume una forma completamente espansa. Può esserti utile includere il mock completo nel `defaults.json` file per scopi di test e sviluppo.

## Elenco degli ambienti
<a name="list-env-bp"></a>

La specificazione di un tipo di matrice `EnvironmentDefinition` genererà un elenco di ambienti nell'interfaccia utente della procedura guidata.

```
export interface Options extends ParentOptions {
    ...
   /**
     @showName readOnly
   */
    myEnvironments:  EnvironmentDefinition<{
        thisIsMyFirstAccountConnection: AccountConnection<{
            thisIsARole: Role<['lambda', 's3', 'dynamo']>;
        }>;
    }>[];

}
```

L'esempio seguente mostra le impostazioni predefinite per un elenco di ambienti:

```
{
  ...
  "myEnvironments": [
  {
    "name": "myProductionEnvironment",
    "environmentType": "PRODUCTION"
  },
  {
    "name": "myDevelopmentEnvironment",
    "environmentType": "DEVELOPMENT"
  },
  ]
}
```

## Esempi di interfacce fittizie
<a name="examples-comp-env-bp"></a>

### Interfaccia fittizia semplice
<a name="simple-comp-env-bp"></a>

```
{
    ...
    "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"
                ]
            }
        }
    }
}
```

### Interfaccia fittizia complessa
<a name="complex-comp-env-bp"></a>

```
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'];
    };
  };
}
```

### Interfaccia fittizia completa
<a name="complete-comp-env-bp"></a>

```
{
  ...
  "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"
        ]
      }
    }
  },
}
```

# Aggiungere componenti segreti a un blueprint
<a name="secrets-comp-bp"></a>

I segreti possono essere utilizzati CodeCatalyst per archiviare dati sensibili a cui è possibile fare riferimento nei flussi di lavoro. Puoi aggiungere un segreto al tuo blueprint personalizzato e farvi riferimento nel tuo flusso di lavoro. Per ulteriori informazioni, consulta [Mascherare i dati utilizzando segreti](workflows-secrets.md).

**Per importare CodeCatalyst i blueprint di Amazon, digita una regione**

Nel tuo `blueprint.ts` file, aggiungi quanto segue:

```
import { Secret, SecretDefinition } from '@amazon-codecatalyst/blueprint-component.secrets'
```

**Topics**
+ [Creare un segreto](#comp-create-secrets-bp)
+ [Fare riferimento a un segreto in un flusso di lavoro](#comp-reference-secrets-bp)

## Creare un segreto
<a name="comp-create-secrets-bp"></a>

L'esempio seguente crea un componente dell'interfaccia utente che richiede all'utente di inserire un valore segreto e una descrizione opzionale:

```
export interface Options extends ParentOptions {
    ...
    mySecret: SecretDefinition;
}


export class Blueprint extends ParentBlueprint {
  constructor(options_: Options) {
    new Secret(this, options.secret);
}
```

Il componente segreto richiede un. `name` Il codice seguente è la forma predefinita minima richiesta:

```
{
    ...
    "secret": {
        "name": "secretName"
    },

}
```

## Fare riferimento a un segreto in un flusso di lavoro
<a name="comp-reference-secrets-bp"></a>

Il seguente blueprint di esempio crea un segreto e un flusso di lavoro che fa riferimento al valore segreto. Per ulteriori informazioni, consulta [Fare riferimento a un segreto in un flusso di lavoro](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(),
    );

}
```

Per ulteriori informazioni sull'utilizzo dei segreti in CodeCatalyst, vedere[Mascherare i dati utilizzando segreti](workflows-secrets.md).

# Aggiungere componenti regionali a un blueprint
<a name="region-comp-bp"></a>

Il tipo di regione può essere aggiunto all'`Options`interfaccia del tuo blueprint personalizzato per generare un componente nella procedura guidata del blueprint, puoi inserire una o più regioni AWS. Il tipo gion può essere importato dal blueprint di base nel file. `blueprint.ts` Per ulteriori informazioni, consulta le [regioni AWS](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/).

**Per importare CodeCatalyst i blueprint di Amazon, digita una regione**

Nel tuo `blueprint.ts` file, aggiungi quanto segue:

```
import { Region } from '@amazon-codecatalyst/blueprints.blueprint'
```

Il parametro del tipo di regione è una serie di codici regionali AWS tra cui scegliere, oppure puoi utilizzarlo `*` per includere tutte le regioni AWS supportate.

**Topics**
+ [Annotazioni](#region-annotations-bp)
+ [Esempi di componenti regionali](#region-components-examples)

## Annotazioni
<a name="region-annotations-bp"></a>

JSDoc i tag possono essere aggiunti a ciascun campo dell'`Options`interfaccia per personalizzare l'aspetto e il comportamento di un campo nella procedura guidata. Per il tipo di regione, sono supportati i seguenti tag:
+ L'`@displayName`annotazione può essere utilizzata per modificare l'etichetta del campo nella procedura guidata.

  Ad esempio: `@displayName AWS Region`
+ L'`@placeholder`annotazione può essere utilizzata per modificare il segnaposto del componente di selezione/multiselezione.

  Ad esempio: `@placeholder Choose AWS Region`

## Esempi di componenti regionali
<a name="region-components-examples"></a>

### Scelta di una regione da un elenco specificato
<a name="region-specified-list-bp"></a>

```
export interface Options extends ParentOptions {
    ...
  /**
   * @displayName Region
   */
  region: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>;
}
```

### Scelta di una o più regioni da un elenco specificato
<a name="region-specified-list-bp"></a>

```
export interface Options extends ParentOptions {
    ...
  /**
   * @displayName Regions
   */
  multiRegion: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>[];
}
```

### Scelta di una regione AWS
<a name="region-one-bp"></a>

```
export interface Options extends ParentOptions {
    ...
  /**
   * @displayName Region
   */
  region: Region<['*']>;
}
```

### Scelta di una o più regioni da un elenco specificato
<a name="region-specified-list-bp"></a>

```
export interface Options extends ParentOptions {
    ...
  /**
   * @displayName Regions
   */
  multiRegion: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>[];
}
```

# Aggiungere componenti del repository e del codice sorgente a un blueprint
<a name="comp-repo-source-bp"></a>

Un repository viene utilizzato da Amazon CodeCatalyst per archiviare il codice. Il repository prende un nome come input. La maggior parte dei componenti è archiviata in un repository, ad esempio file di codice sorgente, flussi di lavoro e altri componenti come gli ambienti di sviluppo gestiti (MDE). Il componente del repository di origine esporta anche i componenti utilizzati per la gestione di file e risorse statiche. I repository hanno vincoli relativi ai nomi. Per ulteriori informazioni, consulta [Archivia e collabora sul codice con i repository di sorgenti in CodeCatalystArchivia e collabora sul codice con i repository di origine](source.md).

```
const repository = new SourceRepository(this, {
  title: 'my-new-repository-title',
});
```

**Per importare i componenti del repository e del codice sorgente di Amazon CodeCatalyst Blueprints**

Nel tuo `blueprint.ts` file, aggiungi quanto segue:

```
import {...} from '@caws-blueprint-component/caws-source-repositories'
```

**Topics**
+ [Aggiungere un file](#repo-add-file-bp)
+ [Aggiungere un file generico](#repo-add-generic-file-bp)
+ [Copiare i file](#repo-copy-file-bp)
+ [Individuazione di più file](#target-multiple-files-bp)
+ [Creare un nuovo repository e aggiungere file](#repo-code-examples-bp)

## Aggiungere un file
<a name="repo-add-file-bp"></a>

È possibile scrivere un file di testo in un repository con il `SourceFile` costrutto. L'operazione è uno dei casi d'uso più comuni e richiede un repository, un percorso di file e contenuti di testo. Se il percorso del file non esiste all'interno di un repository, il componente crea tutte le cartelle richieste.

```
new SourceFile(repository, `path/to/my/file/in/repo/file.txt`, 'my file contents');
```

**Nota**  
Se si scrivono due file nella stessa posizione all'interno dello stesso repository, l'implementazione più recente sovrascrive quella precedente. È possibile utilizzare la funzionalità per sovrapporre il codice generato ed è particolarmente utile per estendere il codice che i blueprint personalizzati potrebbero aver generato.

## Aggiungere un file generico
<a name="repo-add-generic-file-bp"></a>

Puoi scrivere bit arbitrari nel tuo repository. È possibile leggere da un buffer e utilizzare il costrutto. `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());
```

## Copiare i file
<a name="repo-copy-file-bp"></a>

Puoi iniziare con il codice generato copiando e incollando il codice iniziale e quindi generando altro codice su quella base. Inserite il codice all'interno della `static-assets` directory, quindi indirizzate il codice con il costrutto. `StaticAsset` Il percorso in questo caso inizia sempre dalla radice della `static-assets` directory.

```
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 sottoclasse di `StaticAsset` is`SubstitutionAsset`. La sottoclasse funziona esattamente allo stesso modo, ma puoi invece eseguire una sostituzione con i baffi sul file. Può essere utile per eseguire la generazione di stili. copy-and-replace

La sostituzione statica degli asset utilizza un motore di template Moustache per eseguire il rendering dei file statici inseriti nel repository di origine generato. Le regole di creazione dei modelli Moustache vengono applicate durante il rendering, il che significa che tutti i valori sono codificati in HTML per impostazione predefinita. Per eseguire il rendering del codice HTML senza escape, utilizzate la sintassi Triple Mustache. `{{{name}}}` [Per ulteriori informazioni, consulta le regole di creazione dei modelli per moustache.](https://github.com/janl/mustache.js?tab=readme-ov-file#variables)

**Nota**  
L'esecuzione di un sostituto su file che non sono interpretabili dal testo può produrre errori.

```
const starterCodeText = new SubstitionAsset('path/to/file/file.txt').subsitite({
  'my_variable': 'subbed value1',
  'another_variable': 'subbed value2'
})
```

## Individuazione di più file
<a name="target-multiple-files-bp"></a>

Le risorse statiche supportano il targeting globale tramite una funzione statica on `StaticAsset` e le relative sottoclassi chiamate`findAll(...)`, che restituiscono un elenco di risorse statiche precaricate con i relativi percorsi, contenuti e altro. È possibile concatenare l'elenco con `File` costruzioni per copiare e incollare i contenuti nella directory. `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());
```

## Creare un nuovo repository e aggiungere file
<a name="repo-code-examples-bp"></a>

È possibile utilizzare un componente del repository per creare un nuovo repository in un progetto generato. È quindi possibile aggiungere file o flussi di lavoro al repository creato.

```
import { SourceRepository } from '@amazon-codecatalyst/codecatalyst-source-repositories';
...
const repository = new SourceRepository(this, { title: 'myRepo' });
```

L'esempio seguente mostra come aggiungere file e flussi di lavoro a un repository esistente:

```
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 combinazione delle due parti di codice genera un unico repository denominato `myRepo` con un file sorgente `README.md` e un CodeCatalyst flusso di lavoro alla radice.

# Aggiungere componenti del flusso di lavoro a un blueprint
<a name="comp-workflow-bp"></a>

Un flusso di lavoro viene utilizzato dai CodeCatalyst progetti Amazon per eseguire azioni basate su trigger. Puoi utilizzare i componenti del flusso di lavoro per creare e mettere insieme file YAML del flusso di lavoro. Per ulteriori informazioni, consulta [Definizione YAML del flusso di lavoro](workflow-reference.md).

**Per importare i componenti dei flussi di lavoro di Amazon CodeCatalyst Blueprint**

Nel tuo `blueprint.ts` file, aggiungi quanto segue:

```
import { WorkflowBuilder, Workflow } from '@amazon-codecatalyst/codecatalyst-workflows'
```

**Topics**
+ [Esempi di componenti del flusso di lavoro](#comp-workflows-examples-bp)
+ [Connessione a un ambiente](#comp-workflows-connect-env-bp)

## Esempi di componenti del flusso di lavoro
<a name="comp-workflows-examples-bp"></a>

### WorkflowBuilder componente
<a name="comp-workflows-workflowbuilder-bp"></a>

È possibile utilizzare una classe per creare una definizione di flusso di lavoro. La definizione può essere data a un componente del flusso di lavoro per il rendering in un repository.

```
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 Workflow Project
<a name="comp-workflows-projen-bp"></a>

L'esempio seguente mostra come utilizzare un componente Projen per scrivere un flusso di lavoro YAML in un repository:

```
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 ...});
```

## Connessione a un ambiente
<a name="comp-workflows-connect-env-bp"></a>

Molti flussi di lavoro devono essere eseguiti in una connessione a un account AWS. I flussi di lavoro gestiscono questo problema consentendo alle azioni di connettersi ad ambienti con specifiche di account e nomi di ruolo.

```
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),
});
```

# Aggiungere componenti Dev Environments a un blueprint
<a name="comp-dev-env-bp"></a>

Gli ambienti di sviluppo gestiti (MDE) vengono utilizzati per creare e configurare ambienti di lavoro MDE. CodeCatalyst Il componente genera un file. `devfile.yaml` Per ulteriori informazioni, vedere [Introduzione a Devfile](https://redhat-developer.github.io/devfile/) e[Modifica di un devfile del repository per un ambiente di sviluppo](devenvironment-devfile-moving.md).

```
new Workspace(this, repository, SampleWorkspaces.default);
```

**Per importare i componenti delle aree di lavoro di Amazon CodeCatalyst Blueprint**

Nel tuo `blueprint.ts` file, aggiungi quanto segue:

```
import {...} from '@amazon-codecatalyst/codecatalyst-workspaces'
```

# Aggiungere componenti relativi ai problemi a un blueprint
<a name="comp-issues-bp"></a>

In CodeCatalyst, puoi monitorare funzionalità, attività, bug e qualsiasi altro lavoro coinvolto nel tuo progetto. Ogni lavoro è conservato in un registro distinto chiamato problema. Ogni problema può avere una descrizione, un assegnatario, uno stato e altre proprietà, che è possibile cercare, raggruppare e filtrare. Puoi visualizzare i problemi utilizzando le visualizzazioni predefinite oppure puoi creare visualizzazioni personalizzate con filtri, ordinamenti o raggruppamenti personalizzati. Per ulteriori informazioni sui concetti relativi ai problemi, consulta e. [Concetti relativi ai problemi](issues-concepts.md) [Quote per le emissioni in CodeCatalyst](issues-quotas.md)

Il componente issue genera una rappresentazione JSON di un problema. Il componente accetta come input un campo ID e una definizione del problema.

**Per importare CodeCatalyst i blueprint di Amazon, emette componenti.**

Nel tuo `blueprint.ts` file, aggiungi quanto segue:

```
import {...} from '@amazon-codecatalyst/blueprint-component.issues'
```

**Topics**
+ [Problemi, componenti, esempi](#comp-issues-examples-bp)

## Problemi, componenti, esempi
<a name="comp-issues-examples-bp"></a>

### Creazione di un problema
<a name="comp-issues-create-bp"></a>

```
import { Issue } from '@amazon-codecatalyst/blueprint-component.issues';
...
new Issue(this, 'myFirstIssue', {
  title: 'myFirstIssue',
  content: 'This is an example issue.',
});
```

### Creazione di un problema ad alta priorità
<a name="comp-issues-high-priority-bp"></a>

```
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 ...});
```

### Creazione di un problema a bassa priorità con etichette
<a name="comp-issues-low-priority-bp"></a>

```
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'],
});
```

# Utilizzo degli strumenti Blueprint e della CLI
<a name="bp-cli"></a>

La [CLI del blueprint](https://www.npmjs.com/package/@amazon-codecatalyst/blueprint-util.cli) fornisce strumenti per gestire e lavorare con i tuoi blueprint personalizzati.

**Topics**
+ [Lavorare con gli strumenti Blueprint](#working-with-bp-cli)
+ [Strumento di caricamento delle immagini](#image-upload-tool)

## Lavorare con gli strumenti Blueprint
<a name="working-with-bp-cli"></a>

**Per lavorare con gli strumenti del blueprint**

1. Apri la CodeCatalyst console all'indirizzo [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Riprendi il tuo ambiente di sviluppo. Per ulteriori informazioni, consulta [Ripresa del lavoro in un ambiente di sviluppo](devenvironment-resume.md).

   Se non disponi di un ambiente di sviluppo, devi prima crearne uno. Per ulteriori informazioni, consulta [Creazione di un ambiente di sviluppo](devenvironment-create.md).

1. In un terminale funzionante, esegui il seguente comando per installare la CLI del blueprint:

   ```
   npm install -g @amazon-codecatalyst/blueprint-util.cli
   ```

1. Nel `blueprint.ts` file, importa gli strumenti che desideri utilizzare nel seguente formato:

   ```
   import { <tooling-function-name> } from '@amazon-codecatalyst/blueprint-util.cli/lib/<tooling-folder-name>/<tooling-file-name>;
   ```
**Suggerimento**  
Puoi andare su [https://github.com/aws/codecatalyst-blueprints/tree/main/packages/utils/blueprint-cli](https://github.com/aws/codecatalyst-blueprints/tree/main/packages/utils/blueprint-cli)per trovare il nome dell'utensile che desideri utilizzare.

   **Se desideri utilizzare lo strumento di caricamento delle immagini, aggiungi quanto segue allo script:**

   ```
   import { uploadImagePublicly } from '@amazon-codecatalyst/blueprint-util.cli/lib/image-upload-tool/upload-image-to-aws';
   ```

   **Examples** (Esempi)
   + **Se desideri utilizzare la funzione di pubblicazione, aggiungi quanto segue allo script:**

     ```
     import { publish } from '@amazon-codecatalyst/blueprint-util.cli/lib/publish/publish';
     ```
   + **Se desideri utilizzare lo strumento di caricamento delle immagini, aggiungi quanto segue allo script:**

     ```
     import { uploadImagePublicly } from '@amazon-codecatalyst/blueprint-util.cli/lib/image-upload-tool/upload-image-to-aws';
     ```

1. Chiamate la funzione.

   **Esempi:**
   + **Se desideri utilizzare la funzione di pubblicazione, aggiungi quanto segue allo script:**

     ```
     await publish(logger, config.publishEndpoint, {<your publishing options>});
     ```
   + **Se desideri utilizzare lo strumento di caricamento delle immagini, aggiungi quanto segue allo script:**

     ```
     const {imageUrl, imageName} = await uploadImagePublicly(logger, 'path/to/image'));
     ```

## Strumento di caricamento delle immagini
<a name="image-upload-tool"></a>

Lo strumento di caricamento delle immagini ti offre la possibilità di caricare la tua immagine in un bucket S3 nel tuo account AWS e poi distribuirla pubblicamente. CloudFront Lo strumento utilizza come input un percorso dell'immagine nello storage locale (e il nome del bucket opzionale) e restituisce l'URL dell'immagine che è disponibile pubblicamente. Per ulteriori informazioni, consulta [What is Amazon CloudFront?](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Introduction.html) e [cos'è Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html)?

**Per utilizzare lo strumento di caricamento delle immagini**

1. Clona l'[ GitHub archivio di blueprints open source](https://github.com/aws/codecatalyst-blueprints) che fornisce l'accesso al blueprints SDK e ai blueprint di esempio. In un terminale funzionante, esegui il seguente comando:

   ```
   git clone https://github.com/aws/codecatalyst-blueprints.git
   ```

1. Esegui il comando seguente per accedere al GitHub repository dei blueprints:

   ```
   cd codecatalyst-blueprints
   ```

1. Esegui il comando seguente per installare le dipendenze:

   ```
   yarn && yarn build
   ```

1. Esegui il comando seguente per assicurarti che sia installata la versione CLI più recente del blueprint:

   ```
   yarn upgrade @amazon-codecatalyst/blueprint-util.cli
   ```

1. Accedi all'account AWS con il bucket S3 in cui desideri caricare l'immagine. Per ulteriori informazioni, consulta [Configurare l'AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) e [accedere tramite l'interfaccia a riga di comando AWS](https://docs.aws.amazon.com/signin/latest/userguide/command-line-sign-in.html).

1. Esegui il seguente comando dalla radice del tuo CodeCatalyst repository per accedere alla directory con la CLI blueprint:

   ```
   cd packages/utils/blueprint-cli
   ```

1. Esegui il comando seguente per caricare l'immagine in un bucket S3:

   ```
   yarn blueprint upload-image-public <./path/to/your/image> 
         <optional:optional-bucket-name>
   ```

Viene generato un URL per la tua immagine. L'URL non sarà disponibile immediatamente poiché la CloudFront distribuzione richiede del tempo per essere distribuita. Controlla lo stato della distribuzione per ottenere lo stato di distribuzione più recente. Per ulteriori informazioni, consulta [Lavorare con le distribuzioni](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-working-with.html).

# Valutazione delle modifiche all'interfaccia con il test delle istantanee
<a name="testing-bp"></a>

Sono supportati i test di snapshot generati su più configurazioni del tuo blueprint.

I blueprint supportano il [test delle istantanee](https://jestjs.io/docs/snapshot-testing) sulle configurazioni fornite dall'utente in qualità di autore del blueprint. Le configurazioni sono sostituzioni parziali che vengono unite al file defaults.json alla radice di un blueprint. Quando il test delle istantanee è abilitato e configurato, il processo di compilazione e test sintetizza le configurazioni fornite e verifica che gli output sintetizzati non siano cambiati rispetto allo snapshot di riferimento. [Per visualizzare il codice di test delle istantanee, consulta il repository dei blueprints. CodeCatalyst GitHub ](https://github.com/aws/codecatalyst-blueprints/blob/main/packages/utils/projen-blueprint/src/test-snapshot.ts#L12)

**Per abilitare il test delle istantanee**

1. Nel `.projenrc.ts` file, aggiorna l'oggetto di input ProjenBlueprint con i file di cui desideri creare un'istantanea. Per esempio:

   ```
   {
     ....
     blueprintSnapshotConfiguration: {
       snapshotGlobs: ['**', '!environments/**', '!aws-account-to-environment/**'],
     },
   }
   ```

1. Risintetizzate il blueprint per creare TypeScript file nel vostro progetto blueprint. Non modificate i file sorgente poiché sono gestiti e rigenerati da Projen. Utilizza il seguente comando :

   ```
   yarn projen
   ```

1. Vai alla `src/snapshot-configurations` directory per visualizzare il `default-config.json` file con un oggetto vuoto. Aggiorna o sostituisci il file con una o più configurazioni di test personalizzate. Ogni configurazione di test viene quindi unita al `defaults.json` file del progetto, sintetizzata e confrontata con le istantanee durante il test. Usa il seguente comando per testare:

   ```
   yarn test
   ```

   La prima volta che si utilizza un comando test, viene visualizzato il seguente messaggio:`Snapshot Summary › NN snapshots written from 1 test suite`. Le successive esecuzioni di test verificano che l'output sintetizzato non sia cambiato dalle istantanee e visualizzano il seguente messaggio:. `Snapshots: NN passed, NN total`

   Se modifichi intenzionalmente il tuo blueprint per produrre un output diverso, esegui il seguente comando per aggiornare le istantanee di riferimento:

   ```
   yarn test:update
   ```

Le istantanee prevedono che gli output sintetizzati siano costanti tra ogni esecuzione. Se il blueprint genera file che variano, è necessario escludere tali file dal test delle istantanee. Aggiorna l'`blueprintSnapshotConfiguration`oggetto dell'oggetto di `ProjenBluerpint` input per aggiungere la `snapshotGlobs` proprietà. La `snapshotGlobs` proprietà è una matrice di [globi](https://github.com/isaacs/node-glob#glob-primer) che determina quali file sono inclusi o esclusi dall'istantanea.

**Nota**  
Esiste un elenco predefinito di globi. Se si specifica un elenco personalizzato, potrebbe essere necessario ripristinare in modo esplicito le voci predefinite.