Amazon CodeCatalyst ist nicht mehr offen für Neukunden. Bestandskunden können den Service weiterhin wie gewohnt nutzen. Weitere Informationen finden Sie unter [Wie migriert man von CodeCatalyst](migration.md).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Entwicklung eines maßgeschneiderten Entwurfs zur Erfüllung der Projektanforderungen
Bevor Sie einen benutzerdefinierten Blueprint veröffentlichen, können Sie den Blueprint so entwickeln, dass er bestimmte Anforderungen erfüllt. Sie können Ihren benutzerdefinierten Blueprint entwickeln und den Blueprint testen, indem Sie bei der Vorschau ein Projekt erstellen. Sie können den benutzerdefinierten Blueprint so entwickeln, dass er Projektkomponenten wie spezifischen Quellcode, Kontoverbindungen, Workflows, Probleme oder jede andere Komponente enthält, in der erstellt werden kann. CodeCatalyst
**Wichtig**
Wenn Sie Blueprint-Pakete aus externen Quellen verwenden möchten, sollten Sie die Risiken berücksichtigen, die mit diesen Paketen verbunden sein können. Sie sind verantwortlich für die benutzerdefinierten Blueprints, die Sie Ihrem Bereich hinzufügen, und für den Code, den sie generieren.
**Wichtig**
Um einen benutzerdefinierten Blueprint in Ihrem CodeCatalyst Bereich zu entwickeln, müssen Sie mit einem Konto angemeldet sein, dem die Rolle **Space-Administrator oder **Poweruser** in dem Bereich** zugewiesen ist.
**Um einen benutzerdefinierten Blueprint zu entwickeln oder zu aktualisieren**
1. Setzen Sie Ihre Entwicklungsumgebung fort. Weitere Informationen finden Sie unter [Fortsetzen einer Entwicklungsumgebung](devenvironment-resume.md).
Wenn Sie noch keine Entwicklungsumgebung haben, müssen Sie zuerst eine erstellen. Weitere Informationen finden Sie unter [Erstellen einer Entwicklungsumgebung](devenvironment-create.md).
1. Öffnen Sie ein funktionierendes Terminal in Ihrer Entwicklungsumgebung.
1. Wenn Sie sich bei der Erstellung Ihres Blueprints für einen Release-Workflow entschieden haben, wird die neueste Blueprint-Version automatisch veröffentlicht. Rufen Sie die Änderungen ab, um sicherzustellen, dass die `package.json` Datei die inkrementierte Version hat. Verwenden Sie den folgenden Befehl:
```
git pull
```
1. Bearbeiten Sie in der `src/blueprint.ts` Datei die Optionen Ihres benutzerdefinierten Blueprints. Die `Options` Benutzeroberfläche wird vom CodeCatalyst Assistenten dynamisch interpretiert, um eine Auswahlbenutzeroberfläche (UI) zu generieren. Sie können Ihren benutzerdefinierten Blueprint entwickeln, indem Sie Komponenten und unterstützte Tags hinzufügen. Weitere Informationen finden Sie unter [Ändern von Blueprint-Funktionen mit einem Front-End-Assistenten](wizard-bp.md), [Hinzufügen von Umgebungskomponenten zu einem Blueprint](comp-env-bp.md), [Hinzufügen von Regionskomponenten zu einem Blueprint](region-comp-bp.md), [Hinzufügen von Repository- und Quellcode-Komponenten zu einem Blueprint](comp-repo-source-bp.md), [Hinzufügen von Workflow-Komponenten zu einem Blueprint](comp-workflow-bp.md) und [Hinzufügen von Komponenten für Entwicklungsumgebungen zu einem Blueprint](comp-dev-env-bp.md).
Sie können sich auch das Blueprints-SDK und Beispiel-Blueprints ansehen, um zusätzliche Unterstützung bei der Entwicklung Ihres benutzerdefinierten Blueprints zu erhalten. [Weitere Informationen finden Sie im Open-Source-Repository. GitHub ](https://github.com/aws/codecatalyst-blueprints)
Benutzerdefinierte Blueprints bieten als Ergebnis einer erfolgreichen Synthese Vorschau-Bundles. Das Projektpaket stellt den Quellcode, die Konfiguration und die Ressourcen in einem Projekt dar und wird von CodeCatalyst API-Bereitstellungsoperationen zur Bereitstellung in einem Projekt verwendet. Wenn Sie Ihren benutzerdefinierten Blueprint weiterentwickeln möchten, führen Sie den Blueprint-Synthesevorgang erneut aus. Weitere Informationen finden Sie unter [Maßgeschneiderte Blueprint-Konzepte](custom-bp-concepts.md).
# Ändern von Blueprint-Funktionen mit einem Front-End-Assistenten
Ein Assistent zur Blueprint-Auswahl CodeCatalyst wird automatisch von der `Options` Schnittstelle in der `blueprint.ts` Datei generiert. Der Frontend-Assistent unterstützt Änderungen und Funktionen eines Blueprints `Options` mithilfe von Kommentaren und Tags im [JSDOC-Stil](https://jsdoc.app/about-getting-started.html). Sie können Kommentare und Tags im JSDOC-Stil verwenden, um Aufgaben auszuführen. Sie können beispielsweise den über einer Option angezeigten Text auswählen, Funktionen wie die Eingabeüberprüfung aktivieren oder eine Option zusammenklappbar machen. Der Assistent interpretiert einen abstrakten Syntaxbaum (AST), der aus dem TypeScript Typ der `Options` Schnittstelle generiert wurde. Der Assistent konfiguriert sich automatisch so gut wie möglich auf den beschriebenen Typ. Nicht alle Typen werden unterstützt. Zu den anderen unterstützten Typen gehören die Regionsauswahl und die Umgebungsauswahl.
Im Folgenden finden Sie ein Beispiel für einen Assistenten, der JSDOC-Kommentare und -Tags mit Blueprints verwendet: `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[];
}
```
Der Anzeigename jeder Option der `Options` Benutzeroberfläche wird `camelCase` standardmäßig in angezeigt. Klartext im Kommentar im JSDOC-Stil wird als Text über der Option im Assistenten angezeigt.
**Topics**
+ [Unterstützte Tags](#supported-tags-bp)
+ [Unterstützte TypeScript Typen](#supported-typescript-bp)
+ [Kommunikation mit dem Benutzer während der Synthese](#communication-mid-synthesis)
## Unterstützte Tags
Die folgenden JSDOC-Tags werden von benutzerdefinierten Blueprints `Options` im Frontend-Assistenten unterstützt.
### @inlinePolicy. /path/to/policy/file.json
+ **Erfordert**, dass die Option ein Typ `Role` ist.
+ **Verwendung** — Ermöglicht es Ihnen, die Inline-Richtlinien mitzuteilen, die eine Rolle benötigt. Es wird erwartet, dass sich der `policy.json` Pfad im Quellcode befindet. Verwenden Sie dieses Tag, wenn Sie eine benutzerdefinierte Richtlinie für eine Rolle benötigen.
+ **Abhängigkeiten** — `blueprint-cli 0.1.12` und höher
+ **Beispiel** - `@inlinePolicy ./deployment-policy.json`
```
environment: EnvironmentDefinition{
awsAccountConnection: AccountConnection{
/**
* @inlinePolicy ./path/to/deployment-policy.json
*/
cdkRole: Role[];
};
};
```
### @trustPolicy. /path/to/policy/file.json
+ **Erfordert**, dass die Option ein Typ `Role` ist.
+ **Verwendung** — Ermöglicht es Ihnen, die Vertrauensrichtlinien mitzuteilen, die eine Rolle benötigt. Es wird erwartet, dass sich der `policy.json` Pfad im Quellcode befindet. Verwenden Sie dieses Tag, wenn Sie eine benutzerdefinierte Richtlinie für eine Rolle benötigen.
+ **Abhängigkeiten** — `blueprint-cli 0.1.12` und höher
+ **Beispiel** - `@trustPolicy ./trust-policy.json`
```
environment: EnvironmentDefinition{
awsAccountConnection: AccountConnection{
/**
* @trustPolicy ./path/to/trust-policy.json
*/
cdkRole: Role[];
};
};
```
### @validationRegex Regex-Ausdruck
+ **Erfordert, dass** die Option eine Zeichenfolge ist.
+ **Verwendung** — Führt eine Eingabevalidierung für die Option unter Verwendung des angegebenen Regex-Ausdrucks durch und zeigt diese an. `@validationMessage`
+ **Beispiel -** `@validationRegex /^[a-zA-Z0-9_]+$/`
+ **Empfehlung** — Verwenden Sie mit`@validationMessage`. Die Bestätigungsnachricht ist standardmäßig leer.
### @validationMessage -Zeichenfolge
+ **Erfordert** — `@validationRegex` oder andere Fehler, um die Nutzung zu überprüfen.
+ **Verwendung** — Zeigt bei einem `@validation*` Fehler eine Bestätigungsnachricht an.
+ **Beispiel** -`@validationMessage Must contain only upper and lowercase letters, numbers, and underscores`.
+ **Empfehlung** - Verwenden Sie mit`@validationMessage`. Die Bestätigungsnachricht ist standardmäßig leer.
### @collapsed boolean (optional)
+ **Erfordert** - N/A
+ **Usage** — Boolescher Wert, der es ermöglicht, dass eine Unteroption zusammenklappbar ist. Wenn die reduzierte Anmerkung vorhanden ist, ist ihr Standardwert true. Wenn Sie den Wert auf festlegen, `@collapsed false` wird ein zusammenklappbarer Abschnitt erstellt, der zunächst geöffnet ist.
+ **Beispiel** - `@collapsed true`
### @displayName -Zeichenfolge
+ **Erfordert** - N/A
+ **Verwendung** — Ändert den Anzeigenamen der Option. Erlaubt andere Formate als CamelCase für den Anzeigenamen.
+ **Beispiel -** `@displayName Blueprint Name`
### @displayName -Zeichenfolge
+ **Erfordert** - N/A
+ **Verwendung** — Ändert den Anzeigenamen der Option. Erlaubt andere Formate als [CamelCase](https://en.wikipedia.org/wiki/Camel_case) für den Anzeigenamen.
+ **Beispiel -** `@displayName Blueprint Name`
### @defaultEntropy -Nummer
+ **Erfordert**, dass die Option eine Zeichenfolge ist.
+ **Verwendung** — Hängt eine zufällige alphanumerische Zeichenfolge mit einer bestimmten Länge an die Option an.
+ **Beispiel** - `@defaultEntropy 5`
### @placeholder -Zeichenfolge (optional)
+ **Erfordert** - N/A
+ **Verwendung** — Ändert den Standard-Platzhalter für Textfelder.
+ **Beispiel** - `@placeholder type project name here`
### @textArea -Nummer (optional)
+ **Erfordert** — N/A
+ **Verwendung** — Konvertiert Zeichenketteneingaben in eine Textbereichskomponente für größere Textabschnitte. Das Hinzufügen einer Zahl definiert die Anzahl der Zeilen. Die Standardeinstellung ist fünf Zeilen.
+ **Beispiel** - `@textArea 10`
### @hidden boolean (optional)
+ **Erfordert** - N/A
+ **Verwendung** — Versteckt die Datei vor dem Benutzer, sofern die Überprüfung nicht fehlschlägt. Der Standardwert ist wahr.
+ **Beispiel** - `@hidden`
### @button boolean (optional)
+ **Erfordert** - N/A
+ **Verwendung** — Die Anmerkung muss sich auf eine boolesche Eigenschaft beziehen. Fügt eine Schaltfläche hinzu, die bei Auswahl als wahr synthetisiert wird. Kein Schalter.
+ **Beispiel** - `buttonExample: boolean;`
```
/**
* @button
*/
buttonExample: boolean;
```
### @showName boolescher Wert (optional)
+ **Erfordert** — N/A
+ **Verwendung** — Kann nur für einen Kontoverbindungstyp verwendet werden. Zeigt versteckte Namenseingaben an. Standardeinstellung: `default_environment`.
+ **Beispiel** - `@showName true`
```
/**
* @showName true
*/
accountConnection: AccountConnection<{
...
}>;
```
### @ showEnvironmentType boolean (optional)
+ **Erfordert** - N/A
+ **Verwendung** — Kann nur für einen Kontoverbindungstyp verwendet werden. Zeigt das Drop-down-Menü für den versteckten Umgebungstyp an. Alle Verbindungen sind standardmäßig auf. `production` Die Optionen sind „**Nichtproduktion**“ oder „**Produktion**“.
+ **Beispiel** - `@showEnvironmentType true`
```
/**
* @showEnvironmentType true
*/
accountConnection: AccountConnection<{
...
}>;
```
### @forceDefault boolescher Wert (optional)
+ **Erfordert** — N/A
+ **Verwendung** — Verwendet den vom Blueprint-Autor bereitgestellten Standardwert anstelle des Werts, der zuvor vom Benutzer verwendet wurde.
+ **Beispiel** — `forceDeafultExample: any;`
```
/**
* @forceDefault
*/
forceDeafultExample: any;
```
### @requires Blueprint-Name
+ **Erfordert** — Kommentiert die Schnittstelle. `Options`
+ **Verwendung** — Warnt den Benutzer davor, bestimmte Angaben `blueprintName` als Anforderung für den aktuellen Blueprint zum Projekt hinzuzufügen.
+ **Beispiel** - `@requires '@amazon-codecatalyst/blueprints.blueprint-builder'`
```
/*
* @requires '@amazon-codecatalyst/blueprints.blueprint-builder'
*/
export interface Options extends ParentOptions {
...
```
### @filter Regex
+ **Erfordert** — Kommentiert die `Selector` OR-Schnittstelle. `MultiSelect`
+ **Verwendung** — Filtert die Dropdownliste im Assistenten nach Optionen, die der angegebenen Regex entsprechen.
+ **Beispiel** - `@filter /blueprintPackageName/`
```
/**
* @filter /myPackageName/
*/
blueprintInstantiation?: Selector;
...
```
## Unterstützte TypeScript Typen
Die folgenden TypeScript Typen werden von benutzerdefinierten Blueprints `Options` im Front-End-Assistenten unterstützt.
### Anzahl
+ **Erfordert, dass** die Option ein Typ ist. `number`
+ **Verwendung** — Generiert ein Zahleneingabefeld.
+ **Beispiel** - `age: number`
```
{
age: number
...
}
```
### String
+ **Erfordert**, dass die Option ein Typ ist`string`.
+ **Verwendung** — Generiert ein Zeichenketten-Eingabefeld.
+ **Beispiel** - `name: string`
```
{
age: string
...
}
```
### Zeichenfolgenliste
+ **Erfordert**, dass die Option ein Array vom Typ ist`string`.
+ **Verwendung** — Generiert eine Eingabe für eine Zeichenkettenliste.
+ **Beispiel** - `isProduction: boolean`
```
{
isProduction: boolean
...
}
```
### Checkbox
+ **Erfordert**, dass die Option ein ist`boolean`.
+ **Verwendung** — Generieren Sie ein Kontrollkästchen.
+ **Beispiel** - `isProduction: boolean`
```
{
isProduction: boolean
...
}
```
### Radio
+ **Erfordert** — Die Option muss eine Vereinigung von drei oder weniger Zeichenketten sein.
+ **Verwendung** — Generiert ein ausgewähltes Radio.
**Anmerkung**
Wenn vier oder mehr Elemente vorhanden sind, wird dieser Typ als Dropdownmenü gerendert.
+ **Beispiel -** `color: 'red' | 'blue' | 'green'`
```
{
color: 'red' | 'blue' | 'green'
...
}
```
### Dropdown
+ **Erfordert**, dass die Option eine Vereinigung von vier oder mehr Zeichenketten ist.
+ **Verwendung** — Generiert ein Drop-down-Menü.
+ **Beispiel** - `runtimes: 'nodejs' | 'python' | 'java' | 'dotnetcore' | 'ruby'`
```
{
runtimes: 'nodejs' | 'python' | 'java' | 'dotnetcore' | 'ruby'
...
}
```
### Erweiterbarer Bereich
+ **Erfordert**, dass die Option ein Objekt ist.
+ **Verwendung** — Generiert einen erweiterbaren Abschnitt. Die Optionen im Objekt werden im erweiterbaren Bereich des Assistenten verschachtelt.
+ **Beispiel -**
```
{
expandableSectionTitle: {
nestedString: string;
nestedNumber: number;
}
}
```
### Tupel
+ **Erfordert**, dass die Option vom Typ `Tuple` ist.
+ **Verwendung** — Generieren Sie eine bezahlte Eingabe mit Schlüsselwert.
+ **Beispiel -** `tuple: Tuple[string, string]>`
```
{
tuple: Tuple[string, string]>;
...
}
```
### Tupel-Liste
+ **Erfordert**, dass die Option ein Array vom Typ `Tuple` ist.
+ **Verwendung** — Generiert eine Eingabe für eine Tupelliste.
+ **Beispiel** - `tupleList: Tuple[string, string]>[]`
```
{
tupleList: Tuple[string, string]>[];
...
}
```
### Selector
+ **Erfordert**, dass die Option vom Typ ist`Selector`.
+ **Verwendung** — Generiert eine Dropdownliste mit Quell-Repositorys oder Blueprints, die auf ein Projekt angewendet wurden.
+ **Beispiel —** `sourceRepo: Selector`
```
{
sourceRepo: Selector;
sourceRepoOrAdd: Selector;
blueprintInstantiation: Selector;
...
}
```
### Mehrfachauswahl
+ **Erfordert** — Die Option muss vom Typ `Selector` sein.
+ **Verwendung** — Generieren Sie eine Multiselect-Eingabe.
+ **Beispiel** - `multiselect: MultiSelect['A' | 'B' | 'C' | 'D' | 'E']>`
```
{
multiselect: MultiSelect['A' | 'B' | 'C' | 'D' | 'E']>;
...
}
```
## Kommunikation mit dem Benutzer während der Synthese
Als Blueprint-Autor können Sie den Benutzern nicht nur anhand von Bestätigungsnachrichten antworten. Ein Space-Mitglied könnte sich beispielsweise eine Kombination von Optionen ansehen, wodurch ein unklarer Blueprint entsteht. Benutzerdefinierte Blueprints unterstützen die Fähigkeit, Benutzern Fehlermeldungen mitzuteilen, indem die Synthese aufgerufen wird. Der Basis-Blueprint implementiert eine `throwSynthesisError(...)` Funktion, die eine eindeutige Fehlermeldung erwartet. Sie können die Nachricht wie folgt aufrufen:
```
//blueprint.ts
this.throwSynthesisError({
name: BlueprintSynthesisErrorTypes.BlueprintSynthesisError,
message: 'hello from the blueprint! This is a custom error communicated to the user.'
})
```
# Generieren von Eingaben und erneutes Rendern von Frontend-Wizard-Elementen
Sie können Assistenteneingaben mit Dynamic generieren KVInput und dynamisch Front-End-Assistentenelemente für Ihren benutzerdefinierten Blueprint erstellen.
**Topics**
+ [Entwicklungsumgebungen erstellen](#dynamickvinput-bp)
+ [Dynamisches Erstellen von Assistentenelementen](#create-wizard-elements-bp)
## Entwicklungsumgebungen erstellen
Der KVInput Typ Dynamic kann verwendet werden, um Frontend-Assistenteneingaben unter Verwendung der Standardeinstellungen Ihres benutzerdefinierten Blueprints zu generieren. [Die meisten up-to-date Schemas finden Sie in der Dynamic-Definition. KVInput ](https://github.com/aws/codecatalyst-blueprints/blob/main/packages/blueprints/blueprint/src/ui-selectors/dynamic-kv-input.ts)
Das folgende Beispiel zeigt, wie Sie `Options` damit ein Objekt formen können:
```
import { DynamicKVInput } from '@amazon-codecatalyst/blueprints.blueprint';
export interface Options extends ParentOptions {
parameters: DynamicKVInput[];
}
```
Das folgende Beispiel zeigt, wie Sie Standardparameter mit mehreren Eigenschaften festlegen können:
```
{
"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."
}
]
}
```
## Dynamisches Erstellen von Assistentenelementen
Das gleiche Schema wie beim Erstellen von Assistenteneingaben kann verwendet werden, um einen Assistenten während der Synthese dynamisch neu zu rendern. Dies kann verwendet werden, um bei Bedarf weitere Fragen eines Benutzers zu beantworten.
```
//blueprint.ts
export interface Options extends ParentOptions {
...
dynamicOptions: OptionsSchemaDefinition<'optionsIdentifier', KVSchema>;
}
```
Der Assistent kann dann während der Synthesephase mithilfe einer `Options` Komponente eingerichtet werden.
```
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."
}
]);
```
# Hinzufügen von Umgebungskomponenten zu einem Blueprint
Der Assistent für benutzerdefinierte Blueprints wird dynamisch über die `Options` Oberfläche generiert, die über den Assistenten verfügbar gemacht wird. Blueprints unterstützen das Generieren von Benutzeroberflächenkomponenten (UI) aus verfügbaren Typen.
**So importieren Sie Amazon CodeCatalyst Blueprints-Umgebungskomponenten**
Fügen Sie in Ihrer `blueprint.ts` Datei Folgendes hinzu:
```
import {...} from '@amazon-codecatalyst/codecatalyst-environments'
```
**Topics**
+ [Entwicklungsumgebungen erstellen](#create-dev-env-bp)
+ [Liste der Umgebungen](#list-env-bp)
+ [Beispiele für simulierte Benutzeroberflächen](#examples-comp-env-bp)
## Entwicklungsumgebungen erstellen
Das folgende Beispiel zeigt, wie Sie Ihre Anwendung in der Cloud bereitstellen:
```
export interface Options extends ParentOptions {
...
myNewEnvironment: EnvironmentDefinition{
thisIsMyFirstAccountConnection: AccountConnection{
thisIsARole: Role['lambda', 's3', 'dynamo'];
};
};
}
```
Die Schnittstelle generiert eine UI-Komponente, die nach einer neuen Umgebung (`myNewEnvironment`) mit einer einzigen Kontoverbindung () fragt`thisIsMyFirstAccountConnection`. Es wird auch eine Rolle für die Kontoverbindung (`thisIsARole`) generiert, die mindestens die erforderlichen Rollenfunktionen enthält. `['lambda', 's3', 'dynamo']` Nicht alle Benutzer haben Kontoverbindungen, daher sollten Sie prüfen, ob ein Benutzer ein Konto nicht oder kein Konto mit einer Rolle verbindet. Rollen können auch mit `@inlinePolicies` Anmerkungen versehen werden. Weitere Informationen finden Sie unter [@inlinePolicy. /path/to/policy/file.json](wizard-bp.md#inline-policy-tag).
Für die Umgebungskomponente ist ein `name` AND `environmentType` erforderlich. Der folgende Code ist die mindestens erforderliche Standardform:
```
{
...
"myNewEnvironment": {
"name": "myProductionEnvironment",
"environmentType": "PRODUCTION"
},
}
```
Die UI-Komponente fordert Sie dann zur Eingabe verschiedener Felder auf. Wenn Sie die Felder ausfüllen, erhält der Blueprint eine vollständig erweiterte Form. Für Test- und Entwicklungszwecke kann es für Sie hilfreich sein, das vollständige Modell in die `defaults.json` Datei aufzunehmen.
## Liste der Umgebungen
Wenn Sie ein Array vom Typ angeben, `EnvironmentDefinition` wird eine Liste von Umgebungen in der Benutzeroberfläche des Assistenten generiert.
```
export interface Options extends ParentOptions {
...
/**
@showName readOnly
*/
myEnvironments: EnvironmentDefinition<{
thisIsMyFirstAccountConnection: AccountConnection<{
thisIsARole: Role<['lambda', 's3', 'dynamo']>;
}>;
}>[];
}
```
Das folgende Beispiel zeigt die Standardeinstellungen für eine Umgebungsliste:
```
{
...
"myEnvironments": [
{
"name": "myProductionEnvironment",
"environmentType": "PRODUCTION"
},
{
"name": "myDevelopmentEnvironment",
"environmentType": "DEVELOPMENT"
},
]
}
```
## Beispiele für simulierte Benutzeroberflächen
### Einfache Scheinschnittstelle
```
{
...
"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"
]
}
}
}
}
```
### Komplexe Scheinschnittstelle
```
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'];
};
};
}
```
### Vollständige Scheinschnittstelle
```
{
...
"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"
]
}
}
},
}
```
# Secrets-Komponenten zu einem Blueprint hinzufügen
Secrets können verwendet werden CodeCatalyst , um sensible Daten zu speichern, auf die in Workflows verwiesen werden kann. Sie können Ihrem benutzerdefinierten Blueprint ein Geheimnis hinzufügen und in Ihrem Workflow darauf verweisen. Weitere Informationen finden Sie unter [Daten mithilfe von Geheimnissen maskieren](workflows-secrets.md).
**Um Amazon CodeCatalyst Blueprints zu importieren, geben Sie den Regionstyp ein**
Fügen Sie in Ihrer `blueprint.ts` Datei Folgendes hinzu:
```
import { Secret, SecretDefinition } from '@amazon-codecatalyst/blueprint-component.secrets'
```
**Topics**
+ [Ein Geheimnis erstellen](#comp-create-secrets-bp)
+ [Verweisen auf ein Geheimnis in einem Workflow](#comp-reference-secrets-bp)
## Ein Geheimnis erstellen
Im folgenden Beispiel wird eine UI-Komponente erstellt, die den Benutzer auffordert, einen geheimen Wert und eine optionale Beschreibung einzugeben:
```
export interface Options extends ParentOptions {
...
mySecret: SecretDefinition;
}
export class Blueprint extends ParentBlueprint {
constructor(options_: Options) {
new Secret(this, options.secret);
}
```
Die geheime Komponente erfordert eine`name`. Der folgende Code ist die mindestens erforderliche Standardform:
```
{
...
"secret": {
"name": "secretName"
},
}
```
## Verweisen auf ein Geheimnis in einem Workflow
Der folgende Beispiel-Blueprint erstellt einen geheimen Schlüssel und einen Workflow, der auf den geheimen Wert verweist. Weitere Informationen finden Sie unter [Verweisen auf ein Geheimnis in einem Workflow](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(),
);
}
```
Weitere Informationen zur Verwendung von Geheimnissen in finden Sie CodeCatalyst unter[Daten mithilfe von Geheimnissen maskieren](workflows-secrets.md).
# Hinzufügen von Regionskomponenten zu einem Blueprint
Der Regionstyp kann der `Options` Schnittstelle Ihres benutzerdefinierten Blueprints hinzugefügt werden, um eine Komponente zu generieren. Im Blueprint-Assistenten können Sie eine oder mehrere AWS-Gions eingeben. Der Gion-Typ kann aus Ihrem Basis-Blueprint in Ihre Datei importiert werden. `blueprint.ts` Weitere Informationen finden Sie unter [AWS-Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/).
**Um Amazon CodeCatalyst Blueprints zu importieren, geben Sie den Regionstyp ein**
Fügen Sie in Ihrer `blueprint.ts` Datei Folgendes hinzu:
```
import { Region } from '@amazon-codecatalyst/blueprints.blueprint'
```
Der Regionstyp-Parameter ist eine Reihe von AWS-Regionscodes, aus denen Sie wählen können, oder Sie können ihn verwenden, `*` um alle unterstützten AWS-Regionen einzubeziehen.
**Topics**
+ [Anmerkungen](#region-annotations-bp)
+ [Beispiele für Komponenten aus Regionen](#region-components-examples)
## Anmerkungen
JSDoc Zu jedem Feld in der `Options` Benutzeroberfläche können Tags hinzugefügt werden, um die Darstellung und das Verhalten eines Felds im Assistenten anzupassen. Für den Regionstyp werden die folgenden Tags unterstützt:
+ Die `@displayName` Anmerkung kann verwendet werden, um die Bezeichnung des Felds im Assistenten zu ändern.
Beispiel: `@displayName AWS Region`
+ Die `@placeholder` Anmerkung kann verwendet werden, um den Platzhalter der Select-/Multiselect-Komponente zu ändern.
Beispiel: `@placeholder Choose AWS Region`
## Beispiele für Komponenten aus Regionen
### Auswahl einer Region aus einer bestimmten Liste
```
export interface Options extends ParentOptions {
...
/**
* @displayName Region
*/
region: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>;
}
```
### Eine oder mehrere Regionen aus einer bestimmten Liste auswählen
```
export interface Options extends ParentOptions {
...
/**
* @displayName Regions
*/
multiRegion: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>[];
}
```
### Eine AWS-Region auswählen
```
export interface Options extends ParentOptions {
...
/**
* @displayName Region
*/
region: Region<['*']>;
}
```
### Wählen Sie eine oder mehrere Regionen aus einer bestimmten Liste
```
export interface Options extends ParentOptions {
...
/**
* @displayName Regions
*/
multiRegion: Region<['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']>[];
}
```
# Hinzufügen von Repository- und Quellcode-Komponenten zu einem Blueprint
Ein Repository wird von Amazon CodeCatalyst zum Speichern von Code verwendet. Das Repository verwendet einen Namen als Eingabe. Die meisten Komponenten werden in einem Repository gespeichert, z. B. Quellcodedateien, Workflows und andere Komponenten wie verwaltete Entwicklungsumgebungen (MDE). Die Quell-Repository-Komponente exportiert auch Komponenten, die für die Verwaltung von Dateien und statischen Assets verwendet werden. Repositorys haben Namensbeschränkungen. Weitere Informationen finden Sie unter [Speichern Sie Code mit Quell-Repositorys in und arbeiten Sie gemeinsam daran CodeCatalystSpeichern Sie Code mit Quell-Repositorys und arbeiten Sie gemeinsam daran](source.md).
```
const repository = new SourceRepository(this, {
title: 'my-new-repository-title',
});
```
**Um Amazon CodeCatalyst Blueprints, Repository- und Quellcode-Komponenten zu importieren**
Fügen Sie in Ihrer `blueprint.ts` Datei Folgendes hinzu:
```
import {...} from '@caws-blueprint-component/caws-source-repositories'
```
**Topics**
+ [Eine Datei hinzufügen](#repo-add-file-bp)
+ [Eine generische Datei hinzufügen](#repo-add-generic-file-bp)
+ [Dateien werden kopiert](#repo-copy-file-bp)
+ [Ausrichtung auf mehrere Dateien](#target-multiple-files-bp)
+ [Ein neues Repository erstellen und Dateien hinzufügen](#repo-code-examples-bp)
## Eine Datei hinzufügen
Sie können mit dem `SourceFile` Konstrukt eine Textdatei in ein Repository schreiben. Die Operation ist einer der häufigsten Anwendungsfälle und benötigt ein Repository, einen Dateipfad und Textinhalte. Wenn der Dateipfad in einem Repository nicht existiert, erstellt die Komponente alle erforderlichen Ordner.
```
new SourceFile(repository, `path/to/my/file/in/repo/file.txt`, 'my file contents');
```
**Anmerkung**
Wenn Sie zwei Dateien an denselben Speicherort innerhalb desselben Repositorys schreiben, überschreibt die neueste Implementierung die vorherige. Sie können die Funktion verwenden, um generierten Code auf mehrere Ebenen zu legen. Dies ist besonders nützlich, um den Code zu erweitern, den die benutzerdefinierten Blueprints möglicherweise generiert haben.
## Eine generische Datei hinzufügen
Sie können beliebige Bits in Ihr Repository schreiben. Sie können aus einem Puffer lesen und das `File` Konstrukt verwenden.
```
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());
```
## Dateien werden kopiert
Sie können mit generiertem Code beginnen, indem Sie den Startcode kopieren und einfügen und dann weiteren Code auf dieser Basis generieren. Platzieren Sie den Code in dem `static-assets` Verzeichnis und zielen Sie dann auf diesen Code mit dem `StaticAsset` Konstrukt ab. Der Pfad beginnt in diesem Fall immer im `static-assets` Stammverzeichnis.
```
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'
```
Eine Unterklasse von `StaticAsset` ist`SubstitutionAsset`. Die Unterklasse funktioniert genauso, aber stattdessen können Sie stattdessen eine Schnurrbart-Substitution über der Datei ausführen. Dies kann für die Generierung von Stilen nützlich sein. copy-and-replace
Die statische Asset-Substitution verwendet eine Moustache Templating-Engine, um die statischen Dateien zu rendern, die in das generierte Quell-Repository übertragen werden. Die Regeln für Moustache Templates werden beim Rendern angewendet, was bedeutet, dass alle Werte standardmäßig HTML-kodiert sind. Um HTML ohne Escape-Code zu rendern, verwenden Sie die Triple Moustache Syntax. `{{{name}}}` Weitere Informationen finden Sie in den Regeln für [Schnurrbartvorlagen](https://github.com/janl/mustache.js?tab=readme-ov-file#variables).
**Anmerkung**
Das Ausführen eines Ersatzes für Dateien, die nicht textinterpretierbar sind, kann zu Fehlern führen.
```
const starterCodeText = new SubstitionAsset('path/to/file/file.txt').subsitite({
'my_variable': 'subbed value1',
'another_variable': 'subbed value2'
})
```
## Ausrichtung auf mehrere Dateien
Statische Assets unterstützen das globale Targeting über eine statische Funktion on `StaticAsset` und ihre Unterklassen`findAll(...)`, die eine Liste statischer Assets mit ihren Pfaden, Inhalten und mehr zurückgibt, die vorinstalliert sind. Sie können die Liste mit `File` Konstruktionen verketten, um Inhalte zu kopieren und in das Verzeichnis einzufügen. `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());
```
## Ein neues Repository erstellen und Dateien hinzufügen
Sie können eine Repository-Komponente verwenden, um ein neues Repository in einem generierten Projekt zu erstellen. Anschließend können Sie dem erstellten Repository Dateien oder Workflows hinzufügen.
```
import { SourceRepository } from '@amazon-codecatalyst/codecatalyst-source-repositories';
...
const repository = new SourceRepository(this, { title: 'myRepo' });
```
Das folgende Beispiel zeigt, wie Dateien und Workflows zu einem vorhandenen Repository hinzugefügt werden:
```
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...**/});
```
Durch die Kombination der beiden Codeteile wird ein einzelnes Repository `myRepo` mit einer Quelldatei `README.md` und einem CodeCatalyst Workflow im Stammverzeichnis generiert.
# Hinzufügen von Workflow-Komponenten zu einem Blueprint
Ein Workflow wird von CodeCatalyst Amazon-Projekten verwendet, um Aktionen auf der Grundlage von Triggern auszuführen. Sie können Workflow-Komponenten verwenden, um Workflow-YAML-Dateien zu erstellen und zusammenzustellen. Weitere Informationen finden Sie unter [YAML-Workflow-Definition](workflow-reference.md).
**So importieren Sie Workflow-Komponenten von Amazon CodeCatalyst Blueprints**
Fügen Sie in Ihrer `blueprint.ts` Datei Folgendes hinzu:
```
import { WorkflowBuilder, Workflow } from '@amazon-codecatalyst/codecatalyst-workflows'
```
**Topics**
+ [Beispiele für Workflow-Komponenten](#comp-workflows-examples-bp)
+ [Verbindung zu einer Umgebung herstellen](#comp-workflows-connect-env-bp)
## Beispiele für Workflow-Komponenten
### WorkflowBuilder Komponente
Sie können eine Klasse verwenden, um eine Workflow-Definition zu erstellen. Die Definition kann einer Workflow-Komponente zum Rendern in einem Repository zugewiesen werden.
```
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),
});
```
### Workflow-bewährte Komponente
Das folgende Beispiel zeigt, wie eine Projen-Komponente verwendet werden kann, um ein Workflow-YAML in ein Repository zu schreiben:
```
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 ...});
```
## Verbindung zu einer Umgebung herstellen
Viele Workflows müssen in einer AWS-Kontoverbindung ausgeführt werden. Workflows bewältigen dies, indem sie es Aktionen ermöglichen, eine Verbindung zu Umgebungen mit Konto- und Rollennamenspezifikationen herzustellen.
```
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),
});
```
# Hinzufügen von Komponenten für Entwicklungsumgebungen zu einem Blueprint
Verwaltete Entwicklungsumgebungen (MDE) werden verwendet, um MDE-Arbeitsbereiche zu erstellen und einzurichten. CodeCatalyst Die Komponente generiert eine Datei. `devfile.yaml` Weitere Informationen finden Sie unter [Einführung in Devfile](https://redhat-developer.github.io/devfile/) und[Bearbeiten einer Repository-Dev-Datei für eine Entwicklungsumgebung](devenvironment-devfile-moving.md).
```
new Workspace(this, repository, SampleWorkspaces.default);
```
**Um Amazon CodeCatalyst Blueprints Workspaces-Komponenten zu importieren**
Fügen Sie in Ihrer `blueprint.ts` Datei Folgendes hinzu:
```
import {...} from '@amazon-codecatalyst/codecatalyst-workspaces'
```
# Hinzufügen von Problemkomponenten zu einem Blueprint
In CodeCatalyst können Sie Funktionen, Aufgaben, Fehler und alle anderen Arbeiten im Zusammenhang mit Ihrem Projekt überwachen. Jede Arbeit wird in einem eigenen Datensatz gespeichert, der als Problem bezeichnet wird. Jedes Problem kann eine Beschreibung, einen Verantwortlichen, einen Status und andere Eigenschaften haben, nach denen Sie suchen, gruppieren und filtern können. Sie können Ihre Probleme in den Standardansichten anzeigen oder Ihre eigenen Ansichten mit benutzerdefinierter Filterung, Sortierung oder Gruppierung erstellen. Weitere Informationen zu Problemkonzepten finden Sie unter [Problemkonzepte](issues-concepts.md) und[Kontingente für Ausgaben in CodeCatalyst](issues-quotas.md).
Die Problemkomponente generiert eine JSON-Darstellung eines Problems. Die Komponente verwendet ein ID-Feld und eine Problemdefinition als Eingabe.
**So importieren Sie Komponenten für Amazon CodeCatalyst Blueprints-Probleme**
Fügen Sie in Ihrer `blueprint.ts` Datei Folgendes hinzu:
```
import {...} from '@amazon-codecatalyst/blueprint-component.issues'
```
**Topics**
+ [Probleme, Komponenten, Beispiele](#comp-issues-examples-bp)
## Probleme, Komponenten, Beispiele
### Ein Problem wird erstellt
```
import { Issue } from '@amazon-codecatalyst/blueprint-component.issues';
...
new Issue(this, 'myFirstIssue', {
title: 'myFirstIssue',
content: 'This is an example issue.',
});
```
### Ein Problem mit hoher Priorität wird erstellt
```
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 ...});
```
### Erstellung eines Problems mit niedriger Priorität bei Labels
```
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'],
});
```
# Arbeiten mit Blueprint-Tools und CLI
Die [Blueprint-CLI](https://www.npmjs.com/package/@amazon-codecatalyst/blueprint-util.cli) bietet Tools zum Verwalten und Arbeiten mit Ihren benutzerdefinierten Blueprints.
**Topics**
+ [Arbeiten mit Blueprint-Tools](#working-with-bp-cli)
+ [Tool zum Hochladen von Bildern](#image-upload-tool)
## Arbeiten mit Blueprint-Tools
**Um mit den Blueprint-Tools zu arbeiten**
1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Setzen Sie Ihre Entwicklungsumgebung fort. Weitere Informationen finden Sie unter [Fortsetzen einer Entwicklungsumgebung](devenvironment-resume.md).
Wenn Sie noch keine Entwicklungsumgebung haben, müssen Sie zuerst eine erstellen. Weitere Informationen finden Sie unter [Erstellen einer Entwicklungsumgebung](devenvironment-create.md).
1. Führen Sie in einem funktionierenden Terminal den folgenden Befehl aus, um die Blueprint-CLI zu installieren:
```
npm install -g @amazon-codecatalyst/blueprint-util.cli
```
1. Importieren Sie in der `blueprint.ts` Datei die Tools, die Sie verwenden möchten, im folgenden Format:
```
import { } from '@amazon-codecatalyst/blueprint-util.cli/lib//;
```
**Tipp**
Sie können [https://github.com/aws/codecatalyst-blueprints/tree/main/packages/utils/blueprint-cli](https://github.com/aws/codecatalyst-blueprints/tree/main/packages/utils/blueprint-cli)nach dem Namen des Tools suchen, das Sie verwenden möchten.
**Wenn Sie das Tool zum Hochladen von Bildern verwenden möchten, fügen Sie Ihrem Skript Folgendes hinzu:**
```
import { uploadImagePublicly } from '@amazon-codecatalyst/blueprint-util.cli/lib/image-upload-tool/upload-image-to-aws';
```
**Beispiele**
+ **Wenn Sie die Veröffentlichungsfunktion verwenden möchten, fügen Sie Ihrem Skript Folgendes hinzu:**
```
import { publish } from '@amazon-codecatalyst/blueprint-util.cli/lib/publish/publish';
```
+ **Wenn Sie das Tool zum Hochladen von Bildern verwenden möchten, fügen Sie Ihrem Skript Folgendes hinzu:**
```
import { uploadImagePublicly } from '@amazon-codecatalyst/blueprint-util.cli/lib/image-upload-tool/upload-image-to-aws';
```
1. Rufen Sie die Funktion auf.
**Beispiele:**
+ **Wenn Sie die Veröffentlichungsfunktion verwenden möchten, fügen Sie Ihrem Skript Folgendes hinzu:**
```
await publish(logger, config.publishEndpoint, {});
```
+ **Wenn Sie das Tool zum Hochladen von Bildern verwenden möchten, fügen Sie Ihrem Skript Folgendes hinzu:**
```
const {imageUrl, imageName} = await uploadImagePublicly(logger, 'path/to/image'));
```
## Tool zum Hochladen von Bildern
Das Tool zum Hochladen von Bildern bietet Ihnen die Möglichkeit, Ihr eigenes Bild in einen S3-Bucket in Ihrem AWS-Konto hochzuladen und dieses Bild anschließend öffentlich zu verteilen CloudFront. Das Tool verwendet einen Bildpfad im lokalen Speicher (und einen optionalen Bucket-Namen) als Eingabe und gibt die URL zu dem Bild zurück, das öffentlich verfügbar ist. Weitere Informationen finden Sie unter [Was ist Amazon CloudFront?](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Introduction.html) und [Was ist Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html)
**Um mit dem Bild-Upload-Tool zu arbeiten**
1. Klonen Sie das [ GitHub Open-Source-Blueprints-Repository](https://github.com/aws/codecatalyst-blueprints), das Zugriff auf das Blueprints-SDK und Beispiel-Blueprints bietet. Führen Sie in einem funktionierenden Terminal den folgenden Befehl aus:
```
git clone https://github.com/aws/codecatalyst-blueprints.git
```
1. Führen Sie den folgenden Befehl aus, um zum GitHub Blueprints-Repository zu navigieren:
```
cd codecatalyst-blueprints
```
1. Führen Sie den folgenden Befehl aus, um Abhängigkeiten zu installieren:
```
yarn && yarn build
```
1. Führen Sie den folgenden Befehl aus, um sicherzustellen, dass die neueste Blueprint-CLI-Version installiert ist:
```
yarn upgrade @amazon-codecatalyst/blueprint-util.cli
```
1. Melden Sie sich mit dem S3-Bucket, in den Sie Ihr Bild hochladen möchten, beim AWS-Konto an. Weitere Informationen finden [Sie unter AWS-CLI konfigurieren](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) und [Über die AWS-Befehlszeilenschnittstelle anmelden](https://docs.aws.amazon.com/signin/latest/userguide/command-line-sign-in.html).
1. Führen Sie den folgenden Befehl im Stammverzeichnis Ihres CodeCatalyst Repositorys aus, um mit der Blueprint-CLI zu dem Verzeichnis zu navigieren:
```
cd packages/utils/blueprint-cli
```
1. Führen Sie den folgenden Befehl aus, um Ihr Bild in einen S3-Bucket hochzuladen:
```
yarn blueprint upload-image-public <./path/to/your/image>
```
Eine URL zu Ihrem Bild wird generiert. Die URL wird nicht sofort verfügbar sein, da die Bereitstellung der CloudFront Distribution einige Zeit in Anspruch nimmt. Überprüfen Sie den Verteilungsstatus, um den neuesten Bereitstellungsstatus zu erhalten. Weitere Informationen finden Sie unter [Mit Distributionen arbeiten](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-working-with.html).
# Bewertung von Schnittstellenänderungen mit Snapshot-Tests
Generierte Snapshot-Tests in mehreren Konfigurationen Ihres Blueprints werden unterstützt.
Blueprints unterstützen [Snapshot-Tests](https://jestjs.io/docs/snapshot-testing) für Konfigurationen, die Sie als Blueprint-Autor bereitgestellt haben. Bei den Konfigurationen handelt es sich um teilweise Überschreibungen, die über der Datei defaults.json im Stammverzeichnis eines Blueprints zusammengeführt werden. Wenn Snapshot-Tests aktiviert und konfiguriert sind, synthetisiert der Build- und Testprozess die angegebenen Konfigurationen und überprüft, ob sich die synthetisierten Ausgaben gegenüber dem Referenz-Snapshot nicht geändert haben. [Den Snapshot-Testcode finden Sie im Blueprints-Repository. CodeCatalyst GitHub ](https://github.com/aws/codecatalyst-blueprints/blob/main/packages/utils/projen-blueprint/src/test-snapshot.ts#L12)
**Um Snapshot-Tests zu aktivieren**
1. Aktualisieren Sie in der `.projenrc.ts` Datei das Eingabeobjekt ProjenBlueprint mit den Dateien, für die Sie einen Snapshot erstellen möchten. Zum Beispiel:
```
{
....
blueprintSnapshotConfiguration: {
snapshotGlobs: ['**', '!environments/**', '!aws-account-to-environment/**'],
},
}
```
1. Synthetisieren Sie den Blueprint erneut, um TypeScript Dateien in Ihrem Blueprint-Projekt zu erstellen. Bearbeiten Sie die Quelldateien nicht, da sie von Projen verwaltet und neu generiert werden. Verwenden Sie den folgenden Befehl:
```
yarn projen
```
1. Navigieren Sie zu dem `src/snapshot-configurations` Verzeichnis, um die `default-config.json` Datei mit einem leeren Objekt anzuzeigen. Aktualisieren oder ersetzen Sie die Datei durch eine oder mehrere Ihrer eigenen Testkonfigurationen. Jede Testkonfiguration wird dann mit der `defaults.json` Projektdatei zusammengeführt, synthetisiert und beim Testen mit Schnappschüssen verglichen. Verwenden Sie zum Testen den folgenden Befehl:
```
yarn test
```
Wenn Sie zum ersten Mal einen Testbefehl verwenden, wird die folgende Meldung angezeigt:`Snapshot Summary › NN snapshots written from 1 test suite`. Bei nachfolgenden Testläufen wird überprüft, ob sich die synthetisierte Ausgabe gegenüber den Snapshots nicht geändert hat, und es wird die folgende Meldung angezeigt:. `Snapshots: NN passed, NN total`
Wenn Sie Ihren Blueprint absichtlich ändern, um eine andere Ausgabe zu erzeugen, führen Sie den folgenden Befehl aus, um die Referenz-Snapshots zu aktualisieren:
```
yarn test:update
```
Bei Snapshots wird davon ausgegangen, dass die synthetisierten Ausgaben zwischen den einzelnen Durchläufen konstant sind. Wenn Ihr Blueprint Dateien generiert, die variieren, müssen Sie diese Dateien von den Snapshot-Tests ausschließen. Aktualisieren Sie das `blueprintSnapshotConfiguration` Objekt Ihres `ProjenBluerpint` Eingabeobjekts, um die `snapshotGlobs` Eigenschaft hinzuzufügen. Bei der `snapshotGlobs` Eigenschaft handelt es sich um ein Array von [Globs](https://github.com/isaacs/node-glob#glob-primer), das bestimmt, welche Dateien in die Snapshot-Erstellung aufgenommen oder ausgeschlossen werden.
**Anmerkung**
Es gibt eine Standardliste von Globs. Wenn Sie Ihre eigene Liste angeben, müssen Sie möglicherweise die Standardeinträge explizit wiederherstellen.