Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 wurde am 1. Juni 2022 gewartet und der Support wurde am 1. Juni 2023 eingestellt.
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.
# Stellen Sie AWS CDK-Anwendungen bereit
Eine AWS Cloud Development Kit (AWS CDK) -Bereitstellung ist der Prozess der Bereitstellung Ihrer Infrastruktur auf. AWS
## Wie funktionieren AWS CDK-Bereitstellungen
Das AWS CDK nutzt den AWS CloudFormation Dienst zur Durchführung von Bereitstellungen. Vor der Bereitstellung synthetisieren Sie Ihre CDK-Stacks. Dadurch werden eine CloudFormation Vorlage und Bereitstellungsartefakte für jeden CDK-Stack in Ihrer App erstellt. Bereitstellungen werden von einem lokalen Entwicklungscomputer oder von einer *CI/CD-Umgebung (Continuous Integration and Continuous Delivery)* aus initiiert. Während der Bereitstellung werden die Ressourcen auf die Bootstrap-Ressourcen hochgeladen, und die CloudFormation Vorlage wird zur CloudFormation Bereitstellung Ihrer Ressourcen eingereicht. AWS
Damit eine Bereitstellung erfolgreich ist, ist Folgendes erforderlich:
+ Das AWS CDK Command Line Interface (AWS CDK CLI) muss mit gültigen Berechtigungen ausgestattet sein.
+ Die AWS Umgebung muss über ein Bootstrapping verfügen.
+ Das AWS CDK muss die Bootstrap-Ressourcen kennen, in die Assets hochgeladen werden sollen.
## Voraussetzungen für CDK-Bereitstellungen
Bevor Sie eine AWS CDK-Anwendung bereitstellen können, müssen Sie die folgenden Schritte ausführen:
+ Konfigurieren Sie Sicherheitsanmeldedaten für die CDK-CLI.
+ Bootstrap für Ihre Umgebung AWS .
+ Konfigurieren Sie eine AWS Umgebung für jeden Ihrer CDK-Stacks.
+ Entwickeln Sie Ihre CDK-App.
**Konfigurieren Sie Sicherheitsanmeldedaten**
Um die CDK-CLI für die Interaktion zu verwenden AWS, müssen Sie Sicherheitsanmeldedaten auf Ihrem lokalen Computer konfigurieren. Anweisungen finden [Sie unter Sicherheitsanmeldedaten für die AWS CDK-CLI konfigurieren](configure-access.md).
**Bootstrap für Ihre Umgebung AWS **
Eine Bereitstellung ist immer mit einer oder mehreren AWS [Umgebungen](environments.md) verknüpft. Bevor Sie die Bereitstellung durchführen können, muss die Umgebung zuerst [gebootet werden.](bootstrapping.md) Bootstrapping stellt Ressourcen in Ihrer Umgebung bereit, die das CDK zur Durchführung und Verwaltung von Bereitstellungen verwendet. Zu diesen Ressourcen gehören ein Amazon Simple Storage Service (Amazon S3) -Bucket und ein Amazon Elastic Container Registry (Amazon ECR) -Repository zum Speichern und Verwalten von [Ressourcen](assets.md). Zu diesen Ressourcen gehören auch AWS Identitäts- und Zugriffsmanagement-Rollen (IAM), die zur Bereitstellung von Berechtigungen während der Entwicklung und Bereitstellung verwendet werden.
Wir empfehlen, dass Sie den Befehl AWS CDK Command Line Interface (AWS CDK CLI) verwenden, um Ihre `cdk bootstrap` Umgebung zu booten. Sie können das Bootstrapping anpassen oder diese Ressourcen bei Bedarf manuell in Ihrer Umgebung erstellen. Anweisungen finden Sie unter [Bootstrap für Ihre Umgebung zur Verwendung mit dem CDK](bootstrapping-env.md). AWS
**Umgebungen konfigurieren AWS **
Jeder CDK-Stack muss einer Umgebung zugeordnet sein, um zu bestimmen, wo der Stack bereitgestellt wird. Anweisungen finden [Sie unter Umgebungen für die Verwendung mit dem AWS CDK konfigurieren](configure-env.md).
**Entwickeln Sie Ihre CDK-App**
Im Rahmen eines [CDK-Projekts](projects.md) erstellen und entwickeln Sie Ihre CDK-App. [In deiner App erstellst du einen oder mehrere CDK-Stacks.](stacks.md) In Ihren Stacks importieren und verwenden Sie [Konstrukte aus der Construct-Bibliothek](constructs.md), um Ihre AWS Infrastruktur zu definieren. Bevor Sie sie bereitstellen können, muss Ihre CDK-App mindestens einen Stack enthalten.
## CDK-App-Synthese
Für die Synthese empfehlen wir, den `cdk synth` CDK-CLI-Befehl zu verwenden. Der `cdk deploy` Befehl führt auch eine Synthese durch, bevor die Bereitstellung initiiert wird. Mit der Verwendung `cdk synth` können Sie Ihre CDK-App jedoch validieren und Fehler catch bevor Sie mit der Bereitstellung beginnen.
Das Syntheseverhalten wird durch den [Stack-Synthesizer](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html#stack-synthesizers) bestimmt, den Sie für Ihren CDK-Stack konfigurieren. Wenn Sie keinen Synthesizer konfigurieren, ` [DefaultStackSynthesizer](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.DefaultStackSynthesizer.html) ` wird dieser verwendet. Sie können die Synthese auch konfigurieren und an Ihre Bedürfnisse anpassen. Anweisungen finden [Sie unter CDK-Stack-Synthese konfigurieren und durchführen](configure-synth.md).
Damit Ihre synthetisierte CloudFormation Vorlage erfolgreich in Ihrer Umgebung bereitgestellt werden kann, muss sie mit dem Bootstrapping Ihrer Umgebung kompatibel sein. In Ihrer CloudFormation Vorlage muss beispielsweise der richtige Amazon S3 S3-Bucket angegeben werden, in dem Ressourcen bereitgestellt werden sollen. Wenn Sie die Standardmethode für das Bootstrapping Ihrer Umgebung verwenden, funktioniert der Standard-Stack-Synthesizer. Wenn Sie das CDK-Verhalten anpassen, z. B. Bootstrapping oder Synthese, kann das CDK-Bereitstellungsverhalten variieren.
**Der App-Lebenszyklus**
Wenn Sie die Synthese durchführen, durchläuft Ihre CDK-App die folgenden Phasen, die als *App-Lebenszyklus* bezeichnet werden:
**Konstruktion (oder Initialisierung)**
Ihr Code instanziiert alle definierten Konstrukte und verknüpft sie dann miteinander. In dieser Phase werden alle Konstrukte (App, Stacks und ihre untergeordneten Konstrukte) instanziiert und die Konstruktorkette ausgeführt. Der größte Teil Ihres App-Codes wird in dieser Phase ausgeführt.
**Vorbereitung**
Alle Konstrukte, die die `prepare` Methode implementiert haben, werden einer letzten Änderungsrunde unterzogen, um ihren endgültigen Zustand festzulegen. Die Vorbereitungsphase erfolgt automatisch. Als Benutzer erhalten Sie kein Feedback aus dieser Phase. Es kommt selten vor, dass der Hook „Prepare“ verwendet werden muss, und wird generell nicht empfohlen. Seien Sie in dieser Phase sehr vorsichtig, wenn Sie den Konstruktionsbaum mutieren, da die Reihenfolge der Operationen das Verhalten beeinflussen könnte.
Während dieser Phase, sobald der Konstruktionsbaum erstellt wurde, werden alle [Aspekte](aspects.md), die Sie konfiguriert haben, ebenfalls angewendet.
**Validierung**
Alle Konstrukte, die die `validate` Methode implementiert haben, können sich selbst validieren, um sicherzustellen, dass sie sich in einem Zustand befinden, der korrekt bereitgestellt werden kann. Sie werden über alle Validierungsfehler informiert, die während dieser Phase auftreten. Im Allgemeinen empfehlen wir, die Validierung so schnell wie möglich durchzuführen (normalerweise, sobald Sie Eingaben erhalten) und so früh wie möglich Ausnahmen auszulösen. Eine frühzeitige Validierung erhöht die Zuverlässigkeit, da Stack-Traces genauer sind, und stellt sicher, dass Ihr Code weiterhin sicher ausgeführt werden kann.
**Synthese**
Dies ist die letzte Phase der Ausführung Ihrer CDK-App. Es wird durch einen Aufruf von ausgelöst`app.synth()`, durchquert den Konstruktbaum und ruft die `synthesize` Methode für alle Konstrukte auf. Implementierte Konstrukte `synthesize` können an der Synthese teilnehmen und Bereitstellungsartefakte für die resultierende Cloud-Assembly erzeugen. Zu diesen Artefakten gehören CloudFormation Vorlagen, AWS Lambda-Anwendungspakete, Datei- und Docker-Image-Assets und andere Bereitstellungsartefakte. In den meisten Fällen müssen Sie die Methode nicht implementieren. `synthesize`
**Ihre App ausführen**
Die CDK-CLI muss wissen, wie Sie Ihre CDK-App ausführen. Wenn Sie das Projekt mithilfe des `cdk init` Befehls aus einer Vorlage erstellt haben, enthält die `cdk.json` Datei Ihrer App einen `app` Schlüssel. Dieser Schlüssel gibt den erforderlichen Befehl für die Sprache an, in der die App geschrieben ist. Wenn für Ihre Sprache eine Kompilierung erforderlich ist, führt die Befehlszeile diesen Schritt aus, bevor die App automatisch ausgeführt wird.
**Example**
```
{
"app": "npx ts-node --prefer-ts-exts bin/my-app.ts"
}
```
```
{
"app": "node bin/my-app.js"
}
```
```
{
"app": "python app.py"
}
```
```
{
"app": "mvn -e -q compile exec:java"
}
```
```
{
"app": "dotnet run -p src/MyApp/MyApp.csproj"
}
```
```
{
"app": "go mod download && go run my-app.go"
}
```
Wenn Sie Ihr Projekt nicht mit der CDK-CLI erstellt haben oder wenn Sie die unter angegebene Befehlszeile überschreiben möchten`cdk.json`, können Sie die ` --app ` Option bei der Ausführung des `cdk` Befehls angeben.
```
$ cdk --app '' ...
```
Der `` Teil des Befehls gibt den Befehl an, der ausgeführt werden sollte, um Ihre CDK-Anwendung auszuführen. Verwenden Sie Anführungszeichen wie in der Abbildung gezeigt, da solche Befehle Leerzeichen enthalten. Das `` ist ein Unterbefehl wie `synth` oder`deploy`, der der CDK-CLI mitteilt, was Sie mit Ihrer App machen möchten. Folgen Sie dem mit allen zusätzlichen Optionen, die für diesen Unterbefehl benötigt werden.
Die CDK-CLI kann auch direkt mit einer bereits synthetisierten Cloud-Assembly interagieren. Übergeben Sie dazu das Verzeichnis, in dem die Cloud-Assembly gespeichert ist. `--app` Das folgende Beispiel listet die Stacks auf, die in der Cloud-Assembly definiert sind, die unter `./my-cloud-assembly` gespeichert ist.
```
$ cdk --app <./my-cloud-assembly> ls
```
**Cloud-Assemblys**
Der Call to weist `app.synth()` das AWS CDK an, eine Cloud-Assembly aus einer App zu synthetisieren. Normalerweise interagieren Sie nicht direkt mit Cloud-Assemblys. Es handelt sich um Dateien, die alles enthalten, was für die Bereitstellung Ihrer App in einer Cloud-Umgebung erforderlich ist. Es enthält beispielsweise eine AWS CloudFormation Vorlage für jeden Stapel in Ihrer App. Es enthält auch eine Kopie aller Datei-Assets oder Docker-Images, auf die Sie in Ihrer App verweisen.
Einzelheiten zur Formatierung von [Cloud-Assemblys finden Sie in der Cloud-Assembly-Spezifikation](https://github.com/aws/aws-cdk/blob/master/design/cloud-assembly.md).
Um mit der Cloud-Assembly zu interagieren, die Ihre AWS CDK-App erstellt, verwenden Sie normalerweise die AWS CDK-CLI. Für die Bereitstellung Ihrer App kann jedoch jedes Tool verwendet werden, das das Cloud-Assembly-Format lesen kann.
## Bereitstellen der Anwendung
Um Ihre Anwendung bereitzustellen, empfehlen wir, den `cdk deploy` CDK-CLI-Befehl zu verwenden, um Bereitstellungen zu initiieren oder automatisierte Bereitstellungen zu konfigurieren.
Bei der Ausführung wird `cdk deploy` die CDK-CLI initiiert`cdk synth`, um die Bereitstellung vorzubereiten. Das folgende Diagramm veranschaulicht den Lebenszyklus einer App im Kontext einer Bereitstellung:
![\[Flussdiagramm des CDK-App-Lebenszyklus.\]](http://docs.aws.amazon.com/de_de/cdk/v2/guide/images/app-lifecycle_cdk-flowchart.png)
Während der Bereitstellung nimmt die CDK-CLI die durch Synthese erzeugte Cloud-Assembly und stellt sie in einer AWS Umgebung bereit. Die Ressourcen werden auf Amazon S3 und Amazon ECR hochgeladen und die CloudFormation Vorlage wird AWS CloudFormation zur Bereitstellung eingereicht.
Zu Beginn der AWS CloudFormation Bereitstellungsphase ist Ihre CDK-App bereits fertig ausgeführt und wurde beendet. Dies hat folgende Auswirkungen:
+ Die CDK-App kann nicht auf Ereignisse reagieren, die während der Bereitstellung auftreten, z. B. auf die Erstellung einer Ressource oder den Abschluss der gesamten Bereitstellung. Um Code während der Bereitstellungsphase auszuführen, müssen Sie ihn als [benutzerdefinierte](cfn-layer.md#develop-customize-custom) Ressource in die AWS CloudFormation Vorlage einfügen. Weitere Informationen zum Hinzufügen einer benutzerdefinierten Ressource zu Ihrer App finden Sie im [AWS CloudFormation Modul oder im Beispiel](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudformation-readme.html) für eine [benutzerdefinierte Ressource](https://github.com/aws-samples/aws-cdk-examples/tree/master/typescript/custom-resource/). Sie können das [Triggers-Modul](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.triggers-readme.html) auch so konfigurieren, dass Code während der Bereitstellung ausgeführt wird.
+ Die CDK-App muss möglicherweise mit Werten arbeiten, die zum Zeitpunkt der Ausführung noch nicht bekannt sind. Wenn die AWS CDK-App beispielsweise einen Amazon S3 S3-Bucket mit einem automatisch generierten Namen definiert und Sie das `bucket.bucketName` (Python:`bucket_name`) -Attribut abrufen, ist dieser Wert nicht der Name des bereitgestellten Buckets. Stattdessen erhalten Sie einen `Token` Wert. Um festzustellen, ob ein bestimmter Wert verfügbar ist, rufen Sie `cdk.isUnresolved(value)` (Python:`is_unresolved`) auf. Einzelheiten finden Sie unter [Tokens und AWS CDK](tokens.md).
**Bereitstellungsberechtigungen**
Bevor die Bereitstellung durchgeführt werden kann, müssen Berechtigungen eingerichtet werden. Das folgende Diagramm zeigt die Berechtigungen, die während einer Standardbereitstellung verwendet werden, wenn der Standard-Bootstrapping-Prozess und der Stack-Synthesizer verwendet werden:
![\[Flussdiagramm des standardmäßigen CDK-Bereitstellungsprozesses.\]](http://docs.aws.amazon.com/de_de/cdk/v2/guide/images/default-deploy-process_cdk_flowchart.png)
**Der Akteur initiiert die Bereitstellung**
Bereitstellungen werden von einem *Akteur* mithilfe der CDK-CLI initiiert. Ein Akteur kann entweder eine Person oder ein Dienst wie sein. AWS CodePipeline
Falls erforderlich, wird die CDK-CLI ausgeführt, `cdk synth` wenn Sie sie ausführen`cdk deploy`. Während der Synthese geht die AWS Identität davon aus, dass `LookupRole` sie Kontext-Lookups in der AWS Umgebung durchführt.
**Die Berechtigungen sind eingerichtet**
Zunächst werden die Sicherheitsanmeldedaten des Akteurs verwendet, um sich bei der ersten IAM-Identität zu authentifizieren AWS und diese abzurufen. Wie Sicherheitsnachweise konfiguriert und abgerufen werden, hängt für menschliche Akteure davon ab, wie Sie oder Ihr Unternehmen Benutzer verwalten. Weitere Informationen finden [Sie unter Sicherheitsanmeldedaten für die AWS CDK-CLI konfigurieren](configure-access.md). Für Dienstakteure wird z. CodePipeline B. eine IAM-Ausführungsrolle übernommen und verwendet.
Als Nächstes werden die beim Bootstrapping in Ihrer AWS Umgebung erstellten IAM-Rollen verwendet, um Berechtigungen für die Durchführung der für die Bereitstellung erforderlichen Aktionen einzurichten. Weitere Informationen zu diesen Rollen und dazu, wofür sie Berechtigungen gewähren, finden Sie unter Beim Bootstrapping erstellte [IAM-Rollen](bootstrapping-env.md#bootstrapping-env-roles). Dieser Prozess umfasst Folgendes:
+ Die AWS Identität übernimmt die `DeploymentActionRole` Rolle und gibt die `CloudFormationExecutionRole` Rolle an sie weiter. Dabei wird sichergestellt CloudFormation, dass sie die Rolle CloudFormation übernimmt, wenn sie Aktionen in Ihrer AWS Umgebung ausführt. `DeploymentActionRole`erteilt die Erlaubnis zur Durchführung von Bereitstellungen in Ihrer Umgebung und `CloudFormationExecutionRole` legt fest, welche Aktionen ausgeführt CloudFormation werden können.
+ Die AWS Identität nimmt die an`FilePublishingRole`, die bestimmt, welche Aktionen auf dem Amazon S3 S3-Bucket ausgeführt werden können, der beim Bootstrapping erstellt wurde.
+ Die AWS Identität nimmt die an`ImagePublishingRole`, die bestimmt, welche Aktionen auf dem Amazon ECR-Repository ausgeführt werden können, das beim Bootstrapping erstellt wurde.
+ Falls erforderlich, geht die AWS Identität davon aus, dass `LookupRole` sie Kontext-Lookups in der Umgebung durchführt. AWS Diese Aktion kann auch während der Template-Synthese durchgeführt werden.
**Die Bereitstellung wird durchgeführt**
Während der Bereitstellung liest die CDK-CLI den Bootstrap-Versionsparameter, um die Bootstrap-Versionsnummer zu bestätigen. AWS CloudFormation liest diesen Parameter zur Bestätigung auch bei der Bereitstellung. Wenn die Berechtigungen für den gesamten Bereitstellungs-Workflow gültig sind, wird die Bereitstellung durchgeführt. Die Ressourcen werden auf die Bootstrap-Ressourcen hochgeladen, und die bei der Synthese erstellte CloudFormation Vorlage wird bereitgestellt, wobei der CloudFormation Service als CloudFormation Stack für die Bereitstellung Ihrer Ressourcen verwendet wird.
# AWS Validierung der CDK-Richtlinien zum Zeitpunkt der Synthese
## Validierung der Richtlinien zum Zeitpunkt der Synthese
Wenn Sie oder Ihre Organisation ein Tool zur Richtlinienvalidierung wie [AWS CloudFormation Guard](https://docs.aws.amazon.com/cfn-guard/latest/ug/what-is-guard.html) oder [OPA](https://www.openpolicyagent.org/) verwenden, um Einschränkungen für Ihre AWS CloudFormation Vorlage zu definieren, können Sie diese bei der Synthese in das AWS CDK integrieren. Mithilfe des entsprechenden Plug-ins zur Richtlinienvalidierung können Sie die AWS CDK-Anwendung veranlassen, die generierte AWS CloudFormation Vorlage unmittelbar nach der Synthese mit Ihren Richtlinien zu vergleichen. Bei Verstößen schlägt die Synthese fehl und ein Bericht wird auf der Konsole gedruckt.
Die vom AWS CDK zum Zeitpunkt der Synthese durchgeführte Validierung validiert die Kontrollen an einem bestimmten Punkt im Bereitstellungszyklus, sie kann sich jedoch nicht auf Aktionen auswirken, die außerhalb der Synthese stattfinden. Beispiele hierfür sind Aktionen, die direkt in der Konsole oder über einen Dienst APIs ausgeführt werden. Sie sind nicht resistent gegen Änderungen von AWS CloudFormation Vorlagen nach der Synthese. Einige andere Mechanismen, um denselben Regelsatz autoritärer zu validieren, sollten unabhängig eingerichtet werden, wie [AWS CloudFormation Hooks](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/hooks.html) oder [AWS Config](https://docs.aws.amazon.com/config/latest/developerguide/WhatIsConfig.html). Dennoch ist die Fähigkeit des AWS CDK, den Regelsatz während der Entwicklung auszuwerten, nach wie vor nützlich, da dadurch die Erkennungsgeschwindigkeit und die Produktivität der Entwickler verbessert werden.
Das Ziel der Überprüfung der AWS CDK-Richtlinien besteht darin, den während der Entwicklung erforderlichen Einrichtungsaufwand zu minimieren und ihn so einfach wie möglich zu gestalten.
**Anmerkung**
Diese Funktion gilt als experimentell, und sowohl die Plugin-API als auch das Format des Validierungsberichts können sich in future ändern.
## Für Anwendungsentwickler
Um ein oder mehrere Validierungs-Plugins in Ihrer Anwendung zu verwenden, verwenden Sie die `policyValidationBeta1` Eigenschaft von`Stage`:
```
import { CfnGuardValidator } from '@cdklabs/cdk-validator-cfnguard';
const app = new App({
policyValidationBeta1: [
new CfnGuardValidator()
],
});
// only apply to a particular stage
const prodStage = new Stage(app, 'ProdStage', {
policyValidationBeta1: [...],
});
```
Unmittelbar nach der Synthese werden alle auf diese Weise registrierten Plugins aufgerufen, um alle Vorlagen zu validieren, die in dem von Ihnen definierten Bereich generiert wurden. Insbesondere wenn Sie die Vorlagen im `App` Objekt registrieren, werden alle Vorlagen einer Validierung unterzogen.
**Warnung**
Abgesehen von der Änderung der Cloud-Assembly können Plugins alles tun, was Ihre AWS CDK-Anwendung kann. Sie können Daten aus dem Dateisystem lesen, auf das Netzwerk zugreifen usw. Es liegt in Ihrer Verantwortung als Nutzer eines Plugins, zu überprüfen, ob es sicher zu verwenden ist.
### AWS CloudFormation Plugin schützen
Mit dem [https://github.com/cdklabs/cdk-validator-cfnguard](https://github.com/cdklabs/cdk-validator-cfnguard)Plugin können Sie [AWS CloudFormation Guard](https://github.com/aws-cloudformation/cloudformation-guard) verwenden, um Richtlinienvalidierungen durchzuführen. Das `CfnGuardValidator` Plugin verfügt über einen ausgewählten Satz von integrierten [proaktiven AWS Control Tower Tower-Steuerungen](https://docs.aws.amazon.com/controltower/latest/userguide/proactive-controls.html). Das aktuelle Regelwerk finden Sie in der [Projektdokumentation](https://github.com/cdklabs/cdk-validator-cfnguard/blob/main/README.md). Wie bereits im Abschnitt „[Überprüfung der Richtlinien bei der Zusammenfassung](#policy-validation)“ erwähnt, empfehlen wir Organisationen, mithilfe von [AWS CloudFormation Hooks](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/hooks.html) eine aussagekräftigere Validierungsmethode einzuführen.
Für [AWS Control Tower Tower-Kunden](https://docs.aws.amazon.com/controltower/latest/userguide/what-is-control-tower.html) können dieselben proaktiven Kontrollen in Ihrem gesamten Unternehmen eingesetzt werden. Wenn Sie die proaktiven AWS Control Tower Tower-Steuerungen in Ihrer AWS Control Tower Tower-Umgebung aktivieren, können die Kontrollen den Einsatz von nicht konformen Ressourcen verhindern, die über AWS CloudFormation bereitgestellt werden. Weitere Informationen zu verwalteten proaktiven Kontrollen und deren Funktionsweise finden Sie in der [AWS Control Tower Tower-Dokumentation](https://docs.aws.amazon.com/controltower/latest/userguide/proactive-controls.html).
Diese im AWS CDK-Paket enthaltenen Steuerungen und die proaktiven Managed AWS Control Tower Tower-Kontrollen lassen sich am besten zusammen verwenden. In diesem Szenario können Sie dieses Validierungs-Plugin mit denselben proaktiven Kontrollen konfigurieren, die in Ihrer AWS Control Tower Tower-Cloud-Umgebung aktiv sind. Sie können sich dann schnell darauf verlassen, dass Ihre AWS CDK-Anwendung die AWS Control Tower-Kontrollen besteht, indem sie `cdk synth` lokal ausgeführt wird.
### Validierungsbericht
Wenn Sie die AWS CDK-App synthetisieren, werden die Validator-Plugins aufgerufen und die Ergebnisse werden gedruckt. Ein Beispielbericht wird unten angezeigt.
```
Validation Report (CfnGuardValidator)
-------------------------------------
(Summary)
╔═══════════╤════════════════════════╗
║ Status │ failure ║
╟───────────┼────────────────────────╢
║ Plugin │ CfnGuardValidator ║
╚═══════════╧════════════════════════╝
(Violations)
Ensure S3 Buckets are encrypted with a KMS CMK (1 occurrences)
Severity: medium
Occurrences:
- Construct Path: MyStack/MyCustomL3Construct/Bucket
- Stack Template Path: ./cdk.out/MyStack.template.json
- Creation Stack:
└── MyStack (MyStack)
│ Library: aws-cdk-lib.Stack
│ Library Version: 2.50.0
│ Location: Object. (/home/johndoe/tmp/cdk-tmp-app/src/main.ts:25:20)
└── MyCustomL3Construct (MyStack/MyCustomL3Construct)
│ Library: N/A - (Local Construct)
│ Library Version: N/A
│ Location: new MyStack (/home/johndoe/tmp/cdk-tmp-app/src/main.ts:15:20)
└── Bucket (MyStack/MyCustomL3Construct/Bucket)
│ Library: aws-cdk-lib/aws-s3.Bucket
│ Library Version: 2.50.0
│ Location: new MyCustomL3Construct (/home/johndoe/tmp/cdk-tmp-app/src/main.ts:9:20)
- Resource Name: amzn-s3-demo-bucket
- Locations:
> BucketEncryption/ServerSideEncryptionConfiguration/0/ServerSideEncryptionByDefault/SSEAlgorithm
Recommendation: Missing value for key `SSEAlgorithm` - must specify `aws:kms`
How to fix:
> Add to construct properties for `cdk-app/MyStack/Bucket`
`encryption: BucketEncryption.KMS`
Validation failed. See above reports for details
```
Standardmäßig wird der Bericht in einem für Menschen lesbaren Format gedruckt. Wenn Sie einen Bericht im JSON-Format wünschen, aktivieren Sie ihn `@aws-cdk/core:validationReportJson` über die CLI oder übergeben Sie ihn direkt an die Anwendung:
```
const app = new App({
context: { '@aws-cdk/core:validationReportJson': true },
});
```
Alternativ können Sie dieses Kontext-Schlüssel-Wert-Paar mithilfe der `cdk.json` `cdk.context.json` Oder-Dateien in Ihrem Projektverzeichnis festlegen (siehe [Kontextwerte und AWS CDK](context.md)).
Wenn Sie das JSON-Format wählen, druckt das AWS CDK den Richtlinienvalidierungsbericht in einer Datei aus, die `policy-validation-report.json` im Cloud-Assembly-Verzeichnis aufgerufen wird. Für das menschenlesbare Standardformat wird der Bericht in der Standardausgabe gedruckt.
## Für Plugin-Autoren
### Plug-ins
Das AWS CDK-Kernframework ist dafür verantwortlich, Plugins zu registrieren und aufzurufen und dann den formatierten Validierungsbericht anzuzeigen. Die Verantwortung des Plugins besteht darin, als Übersetzungsebene zwischen dem AWS CDK-Framework und dem Tool zur Richtlinienvalidierung zu fungieren. Ein Plugin kann in jeder von AWS CDK unterstützten Sprache erstellt werden. Wenn Sie ein Plugin erstellen, das möglicherweise in mehreren Sprachen verwendet wird, wird empfohlen, das Plugin in zu erstellen, `TypeScript` sodass Sie JSII verwenden können, um das Plugin in jeder AWS CDK-Sprache zu veröffentlichen.
### Plugins erstellen
Das Kommunikationsprotokoll zwischen dem AWS CDK-Kernmodul und Ihrem Policy-Tool wird durch die `IPolicyValidationPluginBeta1` Schnittstelle definiert. Um ein neues Plugin zu erstellen, müssen Sie eine Klasse schreiben, die diese Schnittstelle implementiert. Es gibt zwei Dinge, die du implementieren musst: den Namen des Plugins (indem du die `name` Eigenschaft überschreibst) und die `validate()` Methode.
Das Framework ruft auf `validate()` und übergibt ein `IValidationContextBeta1` Objekt. Der Speicherort der zu validierenden Vorlagen ist gegeben durch`templatePaths`. Das Plugin sollte eine Instanz von zurückgeben`ValidationPluginReportBeta1`. Dieses Objekt stellt den Bericht dar, den der Benutzer am Ende der Synthese erhält.
```
validate(context: IPolicyValidationContextBeta1): PolicyValidationReportBeta1 {
// First read the templates using context.templatePaths...
// ...then perform the validation, and then compose and return the report.
// Using hard-coded values here for better clarity:
return {
success: false,
violations: [{
ruleName: 'CKV_AWS_117',
description: 'Ensure that AWS Lambda function is configured inside a VPC',
fix: 'https://docs.bridgecrew.io/docs/ensure-that-aws-lambda-function-is-configured-inside-a-vpc-1',
violatingResources: [{
resourceName: 'MyFunction3BAA72D1',
templatePath: '/home/johndoe/myapp/cdk.out/MyService.template.json',
locations: 'Properties/VpcConfig',
}],
}],
};
}
```
Beachten Sie, dass Plugins nichts in der Cloud-Assembly ändern dürfen. Jeder Versuch, dies zu tun, führt zu einem Synthesefehler.
Wenn Ihr Plugin von einem externen Tool abhängt, denken Sie daran, dass einige Entwickler dieses Tool möglicherweise noch nicht auf ihren Workstations installiert haben. Um Reibungsverluste zu minimieren, empfehlen wir Ihnen dringend, Ihrem Plugin-Paket ein Installationsskript beizufügen, um den gesamten Prozess zu automatisieren. Besser noch, führe dieses Skript als Teil der Installation deines Pakets aus. Mit `npm` können Sie es beispielsweise dem `postinstall` [Skript](https://docs.npmjs.com/cli/v9/using-npm/scripts) in der `package.json` Datei hinzufügen.
### Umgang mit Ausnahmen
Wenn Ihre Organisation über einen Mechanismus zur Behandlung von Ausnahmen verfügt, kann dieser als Teil des Validator-Plug-ins implementiert werden.
Ein Beispielszenario zur Veranschaulichung eines möglichen Ausnahmemechanismus:
+ In einer Organisation gilt die Regel, dass öffentliche Amazon S3 S3-Buckets nicht erlaubt sind, *außer* in bestimmten Szenarien.
+ Ein Entwickler erstellt einen Amazon S3 S3-Bucket, der unter eines dieser Szenarien fällt, und beantragt eine Ausnahme (z. B. ein Ticket erstellen).
+ Sicherheitstools können aus dem internen System, das Ausnahmen registriert, lesen
In diesem Szenario würde der Entwickler eine Ausnahme im internen System beantragen und dann eine Möglichkeit benötigen, diese Ausnahme zu „registrieren“. Als Ergänzung zum Beispiel für das Guard-Plugin könnten Sie ein Plugin erstellen, das Ausnahmen behandelt, indem es die Verstöße herausfiltert, für die es eine entsprechende Ausnahme in einem internen Ticketsystem gibt.
Beispiele für Implementierungen finden Sie in den vorhandenen Plugins.
+ [@cdklabs/cdk-validator-cfnguard](https://github.com/cdklabs/cdk-validator-cfnguard)
# Kontinuierliche Integration und Bereitstellung (CI/CD) mithilfe von CDK Pipelines
Verwenden Sie das Modul [CDK Pipelines](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.pipelines-readme.html) aus der AWS Construct Library, um die kontinuierliche Bereitstellung von AWS CDK-Anwendungen zu konfigurieren. Wenn Sie den Quellcode Ihrer CDK-App in AWS CodeCommit, oder AWS CodeStar übertragen GitHub, kann CDK Pipelines Ihre neue Version automatisch erstellen, testen und bereitstellen.
CDK Pipelines aktualisieren sich selbst. Wenn Sie Anwendungsstufen oder Stacks hinzufügen, konfiguriert sich die Pipeline automatisch neu, um diese neuen Stufen oder Stacks bereitzustellen.
**Anmerkung**
CDK Pipelines unterstützt zwei. APIs Eine davon ist die ursprüngliche API, die in der CDK Pipelines Developer Preview zur Verfügung gestellt wurde. Bei der anderen handelt es sich um eine moderne API, die das Feedback von CDK-Kunden aus der Vorschauphase berücksichtigt. Die Beispiele in diesem Thema verwenden die moderne API. Einzelheiten zu den Unterschieden zwischen den beiden unterstützten APIs Optionen finden Sie unter [CDK Pipelines Original API](https://github.com/aws/aws-cdk/blob/master/packages/@aws-cdk/pipelines/ORIGINAL_API.md) im * GitHub aws-cdk-Repository*.
## Bootstrap für Ihre Umgebungen AWS
Bevor Sie CDK Pipelines verwenden können, müssen Sie die AWS [Umgebung](environments.md), in der Sie Ihre Stacks bereitstellen, booten.
Eine CDK-Pipeline umfasst mindestens zwei Umgebungen. In der ersten Umgebung wird die Pipeline bereitgestellt. In der zweiten Umgebung möchten Sie die Stacks oder Stages der Anwendung bereitstellen (Stages sind Gruppen verwandter Stacks). Diese Umgebungen können identisch sein, eine bewährte Methode besteht jedoch darin, die Stufen in verschiedenen Umgebungen voneinander zu isolieren.
**Anmerkung**
Weitere Informationen zu den Arten von Ressourcen, die durch [Bootstrapping erstellt werden, und zur Anpassung des Bootstrap-Stacks finden Sie unter AWS CDK-Bootstrapping](bootstrapping.md).
Für die kontinuierliche Bereitstellung mit CDK Pipelines muss Folgendes im CDK Toolkit-Stack enthalten sein:
+ Ein Amazon Simple Storage Service (Amazon S3) -Bucket.
+ Ein Amazon ECR-Repository.
+ IAM-Rollen, um den verschiedenen Teilen einer Pipeline die erforderlichen Berechtigungen zu erteilen.
Das CDK Toolkit aktualisiert Ihren vorhandenen Bootstrap-Stack oder erstellt bei Bedarf einen neuen.
Um eine Umgebung zu booten, die eine AWS CDK-Pipeline bereitstellen kann, rufen Sie `cdk bootstrap` wie im folgenden Beispiel gezeigt auf. Wenn Sie das AWS CDK Toolkit über den `npx` Befehl aufrufen, wird es bei Bedarf vorübergehend installiert. Es wird auch die Version des Toolkits verwenden, die im aktuellen Projekt installiert ist, falls eine existiert.
`--cloudformation-execution-policies`gibt den ARN einer Richtlinie an, unter der future CDK-Pipeline-Bereitstellungen ausgeführt werden. Die `AdministratorAccess` Standardrichtlinie stellt sicher, dass Ihre Pipeline jeden Ressourcentyp bereitstellen kann. AWS Wenn Sie diese Richtlinie verwenden, stellen Sie sicher, dass Sie dem gesamten Code und den Abhängigkeiten vertrauen, aus denen Ihre AWS CDK-App besteht.
Die meisten Organisationen schreiben strengere Kontrollen darüber vor, welche Ressourcen automatisiert eingesetzt werden können. Erkundigen Sie sich bei der zuständigen Abteilung Ihres Unternehmens nach den Richtlinien, die für Ihre Pipeline gelten sollen.
Sie können die `--profile` Option weglassen, wenn Ihr AWS Standardprofil die erforderliche Authentifizierungskonfiguration und AWS Region enthält.
**Example**
```
npx cdk bootstrap aws:/// --profile \
--cloudformation-execution-policies arn:aws:iam::aws:policy/AdministratorAccess
```
```
npx cdk bootstrap aws:// --profile< ADMIN-PROFILE> ^
--cloudformation-execution-policies arn:aws:iam::aws:policy/AdministratorAccess
```
Verwenden Sie stattdessen die folgenden Befehle, um zusätzliche Umgebungen zu starten, in denen AWS CDK-Anwendungen über die Pipeline bereitgestellt werden. Die `--trust` Option gibt an, welches andere Konto über die Berechtigungen zum Bereitstellen von AWS CDK-Anwendungen in dieser Umgebung verfügen soll. Geben Sie für diese Option die AWS Konto-ID der Pipeline an.
Auch hier können Sie die `--profile` Option weglassen, wenn Ihr AWS Standardprofil die erforderliche Authentifizierungskonfiguration und AWS Region enthält.
**Example**
```
npx cdk bootstrap aws:/// --profile \
--cloudformation-execution-policies arn:aws:iam::aws:policy/AdministratorAccess \
--trust
```
```
npx cdk bootstrap aws:/// --profile ^
--cloudformation-execution-policies arn:aws:iam::aws:policy/AdministratorAccess ^
--trust
```
**Tipp**
Verwenden Sie Administratoranmeldedaten nur für das Bootstrap und die Bereitstellung der ersten Pipeline. Verwenden Sie anschließend die Pipeline selbst, nicht Ihren lokalen Computer, um Änderungen bereitzustellen.
Wenn Sie eine ältere Bootstrap-Umgebung aktualisieren, ist der vorherige Amazon S3 S3-Bucket verwaist, wenn der neue Bucket erstellt wird. Löschen Sie es manuell mithilfe der Amazon S3 S3-Konsole.
### Schützen Sie Ihren Bootstrap-Stack vor dem Löschen
Wenn ein Bootstrap-Stack gelöscht wird, werden auch die AWS Ressourcen gelöscht, die ursprünglich in der Umgebung zur Unterstützung von CDK-Bereitstellungen bereitgestellt wurden. Dies führt dazu, dass die Pipeline nicht mehr funktioniert. In diesem Fall gibt es keine allgemeine Lösung für die Wiederherstellung.
Nachdem Ihre Umgebung gebootet wurde, sollten Sie den Bootstrap-Stack der Umgebung nicht löschen und neu erstellen. Versuchen Sie stattdessen, den Bootstrap-Stack auf eine neue Version zu aktualisieren, indem Sie den Befehl erneut ausführen. `cdk bootstrap`
Zum Schutz vor versehentlichem Löschen Ihres Bootstrap-Stacks empfehlen wir Ihnen, die `--termination-protection` Option mit dem `cdk bootstrap` Befehl zum Aktivieren des Kündigungsschutzes bereitzustellen. Sie können den Kündigungsschutz für neue oder bestehende Bootstrap-Stacks aktivieren. Weitere Informationen zu dieser Option finden Sie unter. ` --termination-protection `
Nachdem Sie den Kündigungsschutz aktiviert haben, können Sie die AWS CLI oder die CloudFormation Konsole zur Überprüfung verwenden.
1. Führen Sie den folgenden Befehl aus, um den Kündigungsschutz für einen neuen oder vorhandenen Bootstrap-Stack zu aktivieren:
```
$ cdk bootstrap --termination-protection
```
1. Verwenden Sie die AWS CLI oder die CloudFormation Konsole, um dies zu überprüfen. Das Folgende ist ein Beispiel für die Verwendung der AWS CLI. Wenn Sie Ihren Bootstrap-Stack-Namen geändert haben, `CDKToolkit` ersetzen Sie ihn durch Ihren Stack-Namen:
```
$ aws cloudformation describe-stacks --stack-name --query "Stacks[0].EnableTerminationProtection"
true
```
## Initialisieren Sie ein Projekt
Erstellen Sie ein neues, leeres GitHub Projekt und klonen Sie es auf Ihre Workstation im `my-pipeline` Verzeichnis. (Unsere Codebeispiele in diesem Thema verwenden GitHub. Sie können auch AWS CodeStar oder verwenden AWS CodeCommit.)
```
git clone my-pipeline
cd my-pipeline
```
**Anmerkung**
Sie können einen anderen Namen als den Namen `my-pipeline` für das Hauptverzeichnis Ihrer App verwenden. Wenn Sie dies jedoch tun, müssen Sie die Datei- und Klassennamen später in diesem Thema anpassen. Das liegt daran, dass das AWS CDK Toolkit einige Datei- und Klassennamen auf dem Namen des Hauptverzeichnisses basiert.
Initialisieren Sie das Projekt nach dem Klonen wie gewohnt.
**Example**
```
$ cdk init app --language typescript
```
```
$ cdk init app --language javascript
```
```
$ cdk init app --language python
```
Nachdem die App erstellt wurde, geben Sie auch die folgenden beiden Befehle ein. Diese aktivieren die virtuelle Python-Umgebung der App und installieren die AWS CDK-Kernabhängigkeiten.
```
$ source .venv/bin/activate # On Windows, run `.\venv\Scripts\activate` instead
$ python -m pip install -r requirements.txt
```
```
$ cdk init app --language java
```
Wenn Sie eine IDE verwenden, können Sie das Projekt jetzt öffnen oder importieren. Wählen Sie in Eclipse beispielsweise „**Datei**“ > „**Importieren**“ > „**Maven**“ > „**Bestehende Maven-Projekte**“. Stellen Sie sicher, dass die Projekteinstellungen so eingestellt sind, dass sie Java 8 (1.8) verwenden.
```
$ cdk init app --language csharp
```
Wenn Sie Visual Studio verwenden, öffnen Sie die Lösungsdatei im `src` Verzeichnis.
```
$ cdk init app --language go
```
Geben Sie nach der Erstellung der App auch den folgenden Befehl ein, um die AWS Construct Library-Module zu installieren, die die App benötigt.
```
$ go get
```
**Wichtig**
Stellen Sie sicher, dass Sie Ihre `cdk.json` `cdk.context.json` Dateien der Quellcodeverwaltung übergeben. Die Kontextinformationen (wie Feature-Flags und zwischengespeicherte Werte, die aus Ihrem AWS Konto abgerufen wurden) sind Teil des Status Ihres Projekts. Die Werte können in einer anderen Umgebung unterschiedlich sein, was zu unerwarteten Änderungen Ihrer Ergebnisse führen kann. Weitere Informationen finden Sie unter [Kontextwerte und AWS CDK](context.md).
## Definieren Sie eine Pipeline
Ihre CDK Pipelines Pipelines-Anwendung wird mindestens zwei Stacks enthalten: einen, der die Pipeline selbst darstellt, und einen oder mehrere Stacks, die die über sie bereitgestellte Anwendung darstellen. Stacks können auch in *Stufen* gruppiert werden, mit denen Sie Kopien von Infrastruktur-Stacks in verschiedenen Umgebungen bereitstellen können. Zunächst werden wir uns mit der Pipeline befassen und uns später mit der Anwendung befassen, die sie bereitstellen wird.
Das Konstrukt ` [CodePipeline](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.pipelines.CodePipeline.html) ` ist das Konstrukt, das eine CDK-Pipeline darstellt, die AWS CodePipeline als Deployment Engine verwendet wird. Wenn Sie `CodePipeline` in einem Stack instanziieren, definieren Sie den Quellspeicherort für die Pipeline (z. B. ein GitHub Repository). Sie definieren auch die Befehle zum Erstellen der App.
Im Folgenden wird beispielsweise eine Pipeline definiert, deren Quelle in einem GitHub Repository gespeichert ist. Sie beinhaltet auch einen Build-Schritt für eine TypeScript CDK-Anwendung. Geben Sie die Informationen zu Ihrem GitHub Repo an den angegebenen Stellen ein.
**Anmerkung**
Standardmäßig authentifiziert sich die Pipeline GitHub mit einem persönlichen Zugriffstoken, das in Secrets Manager unter dem Namen `github-token` gespeichert ist.
Sie müssen auch die Instanziierung des Pipeline-Stacks aktualisieren, um das AWS Konto und die Region anzugeben.
**Example**
In `lib/my-pipeline-stack.ts` (kann variieren, wenn Ihr Projektordner nicht benannt `my-pipeline` ist):
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import { CodePipeline, CodePipelineSource, ShellStep } from 'aws-cdk-lib/pipelines';
export class MyPipelineStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
const pipeline = new CodePipeline(this, 'Pipeline', {
pipelineName: 'MyPipeline',
synth: new ShellStep('Synth', {
input: CodePipelineSource.gitHub('OWNER/REPO', 'main'),
commands: ['npm ci', 'npm run build', 'npx cdk synth']
})
});
}
}
```
In `bin/my-pipeline.ts` (kann variieren, wenn Ihr Projektordner nicht benannt ist`my-pipeline`):
```
#!/usr/bin/env node
import * as cdk from 'aws-cdk-lib';
import { MyPipelineStack } from '../lib/my-pipeline-stack';
const app = new cdk.App();
new MyPipelineStack(app, 'MyPipelineStack', {
env: {
account: '111111111111',
region: 'eu-west-1',
}
});
app.synth();
```
In `lib/my-pipeline-stack.js` (kann variieren, wenn Ihr Projektordner nicht benannt ist`my-pipeline`):
```
const cdk = require('aws-cdk-lib');
const { CodePipeline, CodePipelineSource, ShellStep } = require('aws-cdk-lib/pipelines');
class MyPipelineStack extends cdk.Stack {
constructor(scope, id, props) {
super(scope, id, props);
const pipeline = new CodePipeline(this, 'Pipeline', {
pipelineName: 'MyPipeline',
synth: new ShellStep('Synth', {
input: CodePipelineSource.gitHub('OWNER/REPO', 'main'),
commands: ['npm ci', 'npm run build', 'npx cdk synth']
})
});
}
}
module.exports = { MyPipelineStack }
```
In `bin/my-pipeline.js` (kann variieren, wenn Ihr Projektordner nicht benannt ist`my-pipeline`):
```
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { MyPipelineStack } = require('../lib/my-pipeline-stack');
const app = new cdk.App();
new MyPipelineStack(app, 'MyPipelineStack', {
env: {
account: '111111111111',
region: 'eu-west-1',
}
});
app.synth();
```
In `my-pipeline/my-pipeline-stack.py` (kann variieren, wenn Ihr Projektordner nicht benannt ist`my-pipeline`):
```
import aws_cdk as cdk
from constructs import Construct
from aws_cdk.pipelines import CodePipeline, CodePipelineSource, ShellStep
class MyPipelineStack(cdk.Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
pipeline = CodePipeline(self, "Pipeline",
pipeline_name="MyPipeline",
synth=ShellStep("Synth",
input=CodePipelineSource.git_hub("OWNER/REPO", "main"),
commands=["npm install -g aws-cdk",
"python -m pip install -r requirements.txt",
"cdk synth"]
)
)
```
In `app.py`:
```
#!/usr/bin/env python3
import aws_cdk as cdk
from my_pipeline.my_pipeline_stack import MyPipelineStack
app = cdk.App()
MyPipelineStack(app, "MyPipelineStack",
env=cdk.Environment(account="111111111111", region="eu-west-1")
)
app.synth()
```
In `src/main/java/com/myorg/MyPipelineStack.java` (kann variieren, wenn Ihr Projektordner nicht benannt ist`my-pipeline`):
```
package com.myorg;
import java.util.Arrays;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.pipelines.CodePipeline;
import software.amazon.awscdk.pipelines.CodePipelineSource;
import software.amazon.awscdk.pipelines.ShellStep;
public class MyPipelineStack extends Stack {
public MyPipelineStack(final Construct scope, final String id) {
this(scope, id, null);
}
public MyPipelineStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
CodePipeline pipeline = CodePipeline.Builder.create(this, "pipeline")
.pipelineName("MyPipeline")
.synth(ShellStep.Builder.create("Synth")
.input(CodePipelineSource.gitHub("OWNER/REPO", "main"))
.commands(Arrays.asList("npm install -g aws-cdk", "cdk synth"))
.build())
.build();
}
}
```
In `src/main/java/com/myorg/MyPipelineApp.java` (kann variieren, wenn Ihr Projektordner nicht benannt ist`my-pipeline`):
```
package com.myorg;
import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;
public class MyPipelineApp {
public static void main(final String[] args) {
App app = new App();
new MyPipelineStack(app, "PipelineStack", StackProps.builder()
.env(Environment.builder()
.account("111111111111")
.region("eu-west-1")
.build())
.build());
app.synth();
}
}
```
In `src/MyPipeline/MyPipelineStack.cs` (kann variieren, wenn Ihr Projektordner nicht benannt ist`my-pipeline`):
```
using Amazon.CDK;
using Amazon.CDK.Pipelines;
namespace MyPipeline
{
public class MyPipelineStack : Stack
{
internal MyPipelineStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
var pipeline = new CodePipeline(this, "pipeline", new CodePipelineProps
{
PipelineName = "MyPipeline",
Synth = new ShellStep("Synth", new ShellStepProps
{
Input = CodePipelineSource.GitHub("OWNER/REPO", "main"),
Commands = new string[] { "npm install -g aws-cdk", "cdk synth" }
})
});
}
}
}
```
In `src/MyPipeline/Program.cs` (kann variieren, wenn Ihr Projektordner nicht benannt ist`my-pipeline`):
```
using Amazon.CDK;
namespace MyPipeline
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new MyPipelineStack(app, "MyPipelineStack", new StackProps
{
Env = new Amazon.CDK.Environment {
Account = "111111111111", Region = "eu-west-1" }
});
app.Synth();
}
}
}
```
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
codebuild "github.com/aws/aws-cdk-go/awscdk/v2/awscodebuild"
ssm "github.com/aws/aws-cdk-go/awscdk/v2/awsssm"
pipeline "github.com/aws/aws-cdk-go/awscdk/v2/pipelines"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
"os"
)
// my CDK Stack with resources
func NewCdkStack(scope constructs.Construct, id *string, props *awscdk.StackProps) awscdk.Stack {
stack := awscdk.NewStack(scope, id, props)
// create an example ssm parameter
_ = ssm.NewStringParameter(stack, jsii.String("ssm-test-param"), &ssm.StringParameterProps{
ParameterName: jsii.String("/testparam"),
Description: jsii.String("ssm parameter for demo"),
StringValue: jsii.String("my test param"),
})
return stack
}
// my CDK Application
func NewCdkApplication(scope constructs.Construct, id *string, props *awscdk.StageProps) awscdk.Stage {
stage := awscdk.NewStage(scope, id, props)
_ = NewCdkStack(stage, jsii.String("cdk-stack"), &awscdk.StackProps{Env: props.Env})
return stage
}
// my CDK Pipeline
func NewCdkPipeline(scope constructs.Construct, id *string, props *awscdk.StackProps) awscdk.Stack {
stack := awscdk.NewStack(scope, id, props)
// GitHub repo with owner and repository name
githubRepo := pipeline.CodePipelineSource_GitHub(jsii.String("owner/repo"), jsii.String("main"), &pipeline.GitHubSourceOptions{
Authentication: awscdk.SecretValue_SecretsManager(jsii.String("my-github-token"), nil),
})
// self mutating pipeline
myPipeline := pipeline.NewCodePipeline(stack, jsii.String("cdkPipeline"), &pipeline.CodePipelineProps{
PipelineName: jsii.String("CdkPipeline"),
// self mutation true - pipeline changes itself before application deployment
SelfMutation: jsii.Bool(true),
CodeBuildDefaults: &pipeline.CodeBuildOptions{
BuildEnvironment: &codebuild.BuildEnvironment{
// image version 6.0 recommended for newer go version
BuildImage: codebuild.LinuxBuildImage_FromCodeBuildImageId(jsii.String("aws/codebuild/standard:6.0")),
},
},
Synth: pipeline.NewCodeBuildStep(jsii.String("Synth"), &pipeline.CodeBuildStepProps{
Input: githubRepo,
Commands: &[]*string{
jsii.String("npm install -g aws-cdk"),
jsii.String("cdk synth"),
},
}),
})
// deployment of actual CDK application
myPipeline.AddStage(NewCdkApplication(stack, jsii.String("MyApplication"), &awscdk.StageProps{
Env: targetAccountEnv(),
}), &pipeline.AddStageOpts{
Post: &[]pipeline.Step{
pipeline.NewCodeBuildStep(jsii.String("Manual Steps"), &pipeline.CodeBuildStepProps{
Commands: &[]*string{
jsii.String("echo \"My CDK App deployed, manual steps go here ... \""),
},
}),
},
})
return stack
}
// main app
func main() {
defer jsii.Close()
app := awscdk.NewApp(nil)
// call CDK Pipeline
NewCdkPipeline(app, jsii.String("CdkPipelineStack"), &awscdk.StackProps{
Env: pipelineEnv(),
})
app.Synth(nil)
}
// env determines the AWS environment (account+region) in which our stack is to
// be deployed. For more information see: https://docs.aws.amazon.com/cdk/latest/guide/environments.html
func pipelineEnv() *awscdk.Environment {
return &awscdk.Environment{
Account: jsii.String(os.Getenv("CDK_DEFAULT_ACCOUNT")),
Region: jsii.String(os.Getenv("CDK_DEFAULT_REGION")),
}
}
func targetAccountEnv() *awscdk.Environment {
return &awscdk.Environment{
Account: jsii.String(os.Getenv("CDK_DEFAULT_ACCOUNT")),
Region: jsii.String(os.Getenv("CDK_DEFAULT_REGION")),
}
}
```
Sie müssen eine Pipeline einmal manuell bereitstellen. Danach hält sich die Pipeline aus dem Quellcode-Repository auf dem neuesten Stand. Stellen Sie also sicher, dass der Code im Repo der Code ist, den Sie bereitstellen möchten. Checken Sie Ihre Änderungen ein GitHub, klicken Sie auf und stellen Sie sie dann bereit:
```
git add --all
git commit -m "initial commit"
git push
cdk deploy
```
**Tipp**
Nachdem Sie die erste Bereitstellung abgeschlossen haben, benötigt Ihr lokales AWS Konto keinen Administratorzugriff mehr. Dies liegt daran, dass alle Änderungen an Ihrer App über die Pipeline bereitgestellt werden. Sie müssen lediglich in der Lage sein, darauf zu drücken GitHub.
## Phasen der Bewerbung
Um eine AWS Multi-Stack-Anwendung zu definieren, die der Pipeline auf einmal hinzugefügt werden kann, definieren Sie eine Unterklasse von. ` [Stage](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stage.html) ` (Dies unterscheidet sich von `CdkStage` dem Modul CDK Pipelines.)
Die Phase enthält die Stapel, aus denen Ihre Anwendung besteht. Wenn zwischen den Stacks Abhängigkeiten bestehen, werden die Stacks automatisch in der richtigen Reihenfolge zur Pipeline hinzugefügt. Stacks, die nicht voneinander abhängen, werden parallel bereitgestellt. Sie können eine Abhängigkeitsbeziehung zwischen Stacks hinzufügen, indem Sie aufrufen. `stack1.addDependency(stack2)`
Stufen akzeptieren ein `env` Standardargument, das zur Standardumgebung für die darin enthaltenen Stacks wird. (Für Stacks kann immer noch eine eigene Umgebung angegeben werden.).
Eine Anwendung wird der Pipeline hinzugefügt, indem sie ` [addStage()](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.pipelines.CodePipeline.html#addwbrstagestage-optionss) ` mit Instanzen von [Stage](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stage.html) aufruft. Eine Phase kann mehrmals instanziiert und der Pipeline hinzugefügt werden, um verschiedene Phasen Ihrer DTAP- oder Multi-Region-Anwendungspipeline zu definieren.
Wir werden einen Stack erstellen, der eine einfache Lambda-Funktion enthält, und diesen Stack in einer Phase platzieren. Dann fügen wir die Phase der Pipeline hinzu, damit sie bereitgestellt werden kann.
**Example**
Erstellen Sie die neue Datei`lib/my-pipeline-lambda-stack.ts`, die unseren Anwendungsstapel enthält, der eine Lambda-Funktion enthält.
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import { Function, InlineCode, Runtime } from 'aws-cdk-lib/aws-lambda';
export class MyLambdaStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
new Function(this, 'LambdaFunction', {
runtime: Runtime.NODEJS_18_X,
handler: 'index.handler',
code: new InlineCode('exports.handler = _ => "Hello, CDK";')
});
}
}
```
Erstellen Sie die neue Datei `lib/my-pipeline-app-stage.ts` für unsere Bühne.
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from "constructs";
import { MyLambdaStack } from './my-pipeline-lambda-stack';
export class MyPipelineAppStage extends cdk.Stage {
constructor(scope: Construct, id: string, props?: cdk.StageProps) {
super(scope, id, props);
const lambdaStack = new MyLambdaStack(this, 'LambdaStack');
}
}
```
Bearbeiten`lib/my-pipeline-stack.ts`, um die Phase zu unserer Pipeline hinzuzufügen.
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import { CodePipeline, CodePipelineSource, ShellStep } from 'aws-cdk-lib/pipelines';
import { MyPipelineAppStage } from './my-pipeline-app-stage';
export class MyPipelineStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
const pipeline = new CodePipeline(this, 'Pipeline', {
pipelineName: 'MyPipeline',
synth: new ShellStep('Synth', {
input: CodePipelineSource.gitHub('OWNER/REPO', 'main'),
commands: ['npm ci', 'npm run build', 'npx cdk synth']
})
});
pipeline.addStage(new MyPipelineAppStage(this, "test", {
env: { account: "111111111111", region: "eu-west-1" }
}));
}
}
```
Erstellen Sie die neue Datei`lib/my-pipeline-lambda-stack.js`, die unseren Anwendungsstapel enthält, der eine Lambda-Funktion enthält.
```
const cdk = require('aws-cdk-lib');
const { Function, InlineCode, Runtime } = require('aws-cdk-lib/aws-lambda');
class MyLambdaStack extends cdk.Stack {
constructor(scope, id, props) {
super(scope, id, props);
new Function(this, 'LambdaFunction', {
runtime: Runtime.NODEJS_18_X,
handler: 'index.handler',
code: new InlineCode('exports.handler = _ => "Hello, CDK";')
});
}
}
module.exports = { MyLambdaStack }
```
Erstellen Sie die neue Datei `lib/my-pipeline-app-stage.js` für unsere Bühne.
```
const cdk = require('aws-cdk-lib');
const { MyLambdaStack } = require('./my-pipeline-lambda-stack');
class MyPipelineAppStage extends cdk.Stage {
constructor(scope, id, props) {
super(scope, id, props);
const lambdaStack = new MyLambdaStack(this, 'LambdaStack');
}
}
module.exports = { MyPipelineAppStage };
```
Bearbeiten`lib/my-pipeline-stack.ts`, um die Phase zu unserer Pipeline hinzuzufügen.
```
const cdk = require('aws-cdk-lib');
const { CodePipeline, CodePipelineSource, ShellStep } = require('aws-cdk-lib/pipelines');
const { MyPipelineAppStage } = require('./my-pipeline-app-stage');
class MyPipelineStack extends cdk.Stack {
constructor(scope, id, props) {
super(scope, id, props);
const pipeline = new CodePipeline(this, 'Pipeline', {
pipelineName: 'MyPipeline',
synth: new ShellStep('Synth', {
input: CodePipelineSource.gitHub('OWNER/REPO', 'main'),
commands: ['npm ci', 'npm run build', 'npx cdk synth']
})
});
pipeline.addStage(new MyPipelineAppStage(this, "test", {
env: { account: "111111111111", region: "eu-west-1" }
}));
}
}
module.exports = { MyPipelineStack }
```
Erstellen Sie die neue Datei`my_pipeline/my_pipeline_lambda_stack.py`, die unseren Anwendungsstapel enthält, der eine Lambda-Funktion enthält.
```
import aws_cdk as cdk
from constructs import Construct
from aws_cdk.aws_lambda import Function, InlineCode, Runtime
class MyLambdaStack(cdk.Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
Function(self, "LambdaFunction",
runtime=Runtime.NODEJS_18_X,
handler="index.handler",
code=InlineCode("exports.handler = _ => 'Hello, CDK';")
)
```
Erstellen Sie die neue Datei `my_pipeline/my_pipeline_app_stage.py` für unsere Bühne.
```
import aws_cdk as cdk
from constructs import Construct
from my_pipeline.my_pipeline_lambda_stack import MyLambdaStack
class MyPipelineAppStage(cdk.Stage):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
lambdaStack = MyLambdaStack(self, "LambdaStack")
```
Bearbeiten`my_pipeline/my-pipeline-stack.py`, um die Phase zu unserer Pipeline hinzuzufügen.
```
import aws_cdk as cdk
from constructs import Construct
from aws_cdk.pipelines import CodePipeline, CodePipelineSource, ShellStep
from my_pipeline.my_pipeline_app_stage import MyPipelineAppStage
class MyPipelineStack(cdk.Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
pipeline = CodePipeline(self, "Pipeline",
pipeline_name="MyPipeline",
synth=ShellStep("Synth",
input=CodePipelineSource.git_hub("OWNER/REPO", "main"),
commands=["npm install -g aws-cdk",
"python -m pip install -r requirements.txt",
"cdk synth"]))
pipeline.add_stage(MyPipelineAppStage(self, "test",
env=cdk.Environment(account="111111111111", region="eu-west-1")))
```
Erstellen Sie die neue Datei`src/main/java/com.myorg/MyPipelineLambdaStack.java`, die unseren Anwendungsstapel enthält, der eine Lambda-Funktion enthält.
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;
import software.amazon.awscdk.services.lambda.InlineCode;
public class MyPipelineLambdaStack extends Stack {
public MyPipelineLambdaStack(final Construct scope, final String id) {
this(scope, id, null);
}
public MyPipelineLambdaStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
Function.Builder.create(this, "LambdaFunction")
.runtime(Runtime.NODEJS_18_X)
.handler("index.handler")
.code(new InlineCode("exports.handler = _ => 'Hello, CDK';"))
.build();
}
}
```
Erstellen Sie die neue Datei `src/main/java/com.myorg/MyPipelineAppStage.java` für unsere Bühne.
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.Stage;
import software.amazon.awscdk.StageProps;
public class MyPipelineAppStage extends Stage {
public MyPipelineAppStage(final Construct scope, final String id) {
this(scope, id, null);
}
public MyPipelineAppStage(final Construct scope, final String id, final StageProps props) {
super(scope, id, props);
Stack lambdaStack = new MyPipelineLambdaStack(this, "LambdaStack");
}
}
```
Bearbeiten`src/main/java/com.myorg/MyPipelineStack.java`, um die Phase zu unserer Pipeline hinzuzufügen.
```
package com.myorg;
import java.util.Arrays;
import software.constructs.Construct;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.StageProps;
import software.amazon.awscdk.pipelines.CodePipeline;
import software.amazon.awscdk.pipelines.CodePipelineSource;
import software.amazon.awscdk.pipelines.ShellStep;
public class MyPipelineStack extends Stack {
public MyPipelineStack(final Construct scope, final String id) {
this(scope, id, null);
}
public MyPipelineStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
final CodePipeline pipeline = CodePipeline.Builder.create(this, "pipeline")
.pipelineName("MyPipeline")
.synth(ShellStep.Builder.create("Synth")
.input(CodePipelineSource.gitHub("OWNER/REPO", "main"))
.commands(Arrays.asList("npm install -g aws-cdk", "cdk synth"))
.build())
.build();
pipeline.addStage(new MyPipelineAppStage(this, "test", StageProps.builder()
.env(Environment.builder()
.account("111111111111")
.region("eu-west-1")
.build())
.build()));
}
}
```
Erstellen Sie die neue Datei`src/MyPipeline/MyPipelineLambdaStack.cs`, die unseren Anwendungsstapel enthält, der eine Lambda-Funktion enthält.
```
using Amazon.CDK;
using Constructs;
using Amazon.CDK.AWS.Lambda;
namespace MyPipeline
{
class MyPipelineLambdaStack : Stack
{
public MyPipelineLambdaStack(Construct scope, string id, StackProps props=null) : base(scope, id, props)
{
new Function(this, "LambdaFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_18_X,
Handler = "index.handler",
Code = new InlineCode("exports.handler = _ => 'Hello, CDK';")
});
}
}
}
```
Erstellen Sie die neue Datei `src/MyPipeline/MyPipelineAppStage.cs` für unsere Bühne.
```
using Amazon.CDK;
using Constructs;
namespace MyPipeline
{
class MyPipelineAppStage : Stage
{
public MyPipelineAppStage(Construct scope, string id, StageProps props=null) : base(scope, id, props)
{
Stack lambdaStack = new MyPipelineLambdaStack(this, "LambdaStack");
}
}
}
```
Bearbeiten`src/MyPipeline/MyPipelineStack.cs`, um die Phase zu unserer Pipeline hinzuzufügen.
```
using Amazon.CDK;
using Constructs;
using Amazon.CDK.Pipelines;
namespace MyPipeline
{
public class MyPipelineStack : Stack
{
internal MyPipelineStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
var pipeline = new CodePipeline(this, "pipeline", new CodePipelineProps
{
PipelineName = "MyPipeline",
Synth = new ShellStep("Synth", new ShellStepProps
{
Input = CodePipelineSource.GitHub("OWNER/REPO", "main"),
Commands = new string[] { "npm install -g aws-cdk", "cdk synth" }
})
});
pipeline.AddStage(new MyPipelineAppStage(this, "test", new StageProps
{
Env = new Environment
{
Account = "111111111111", Region = "eu-west-1"
}
}));
}
}
}
```
Jede von hinzugefügte Anwendungsphase `addStage()` führt zum Hinzufügen einer entsprechenden Pipeline-Phase, die durch eine vom `addStage()` Aufruf zurückgegebene ` [StageDeployment](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.pipelines.StageDeployment.html) ` Instanz repräsentiert wird. Sie können der Phase Aktionen vor oder nach der Bereitstellung hinzufügen, indem Sie die Methode `addPre()` or `addPost()` aufrufen.
**Example**
```
// import { ManualApprovalStep } from 'aws-cdk-lib/pipelines';
const testingStage = pipeline.addStage(new MyPipelineAppStage(this, 'testing', {
env: { account: '111111111111', region: 'eu-west-1' }
}));
testingStage.addPost(new ManualApprovalStep('approval'));
```
```
// const { ManualApprovalStep } = require('aws-cdk-lib/pipelines');
const testingStage = pipeline.addStage(new MyPipelineAppStage(this, 'testing', {
env: { account: '111111111111', region: 'eu-west-1' }
}));
testingStage.addPost(new ManualApprovalStep('approval'));
```
```
# from aws_cdk.pipelines import ManualApprovalStep
testing_stage = pipeline.add_stage(MyPipelineAppStage(self, "testing",
env=cdk.Environment(account="111111111111", region="eu-west-1")))
testing_stage.add_post(ManualApprovalStep('approval'))
```
```
// import software.amazon.awscdk.pipelines.StageDeployment;
// import software.amazon.awscdk.pipelines.ManualApprovalStep;
StageDeployment testingStage =
pipeline.addStage(new MyPipelineAppStage(this, "test", StageProps.builder()
.env(Environment.builder()
.account("111111111111")
.region("eu-west-1")
.build())
.build()));
testingStage.addPost(new ManualApprovalStep("approval"));
```
```
var testingStage = pipeline.AddStage(new MyPipelineAppStage(this, "test", new StageProps
{
Env = new Environment
{
Account = "111111111111", Region = "eu-west-1"
}
}));
testingStage.AddPost(new ManualApprovalStep("approval"));
```
Sie können Phasen zu a hinzufügen, ` [Wave](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.pipelines.Wave.html) ` um sie parallel bereitzustellen, z. B. wenn Sie eine Phase für mehrere Konten oder Regionen bereitstellen.
**Example**
```
const wave = pipeline.addWave('wave');
wave.addStage(new MyApplicationStage(this, 'MyAppEU', {
env: { account: '111111111111', region: 'eu-west-1' }
}));
wave.addStage(new MyApplicationStage(this, 'MyAppUS', {
env: { account: '111111111111', region: 'us-west-1' }
}));
```
```
const wave = pipeline.addWave('wave');
wave.addStage(new MyApplicationStage(this, 'MyAppEU', {
env: { account: '111111111111', region: 'eu-west-1' }
}));
wave.addStage(new MyApplicationStage(this, 'MyAppUS', {
env: { account: '111111111111', region: 'us-west-1' }
}));
```
```
wave = pipeline.add_wave("wave")
wave.add_stage(MyApplicationStage(self, "MyAppEU",
env=cdk.Environment(account="111111111111", region="eu-west-1")))
wave.add_stage(MyApplicationStage(self, "MyAppUS",
env=cdk.Environment(account="111111111111", region="us-west-1")))
```
```
// import software.amazon.awscdk.pipelines.Wave;
final Wave wave = pipeline.addWave("wave");
wave.addStage(new MyPipelineAppStage(this, "MyAppEU", StageProps.builder()
.env(Environment.builder()
.account("111111111111")
.region("eu-west-1")
.build())
.build()));
wave.addStage(new MyPipelineAppStage(this, "MyAppUS", StageProps.builder()
.env(Environment.builder()
.account("111111111111")
.region("us-west-1")
.build())
.build()));
```
```
var wave = pipeline.AddWave("wave");
wave.AddStage(new MyPipelineAppStage(this, "MyAppEU", new StageProps
{
Env = new Environment
{
Account = "111111111111", Region = "eu-west-1"
}
}));
wave.AddStage(new MyPipelineAppStage(this, "MyAppUS", new StageProps
{
Env = new Environment
{
Account = "111111111111", Region = "us-west-1"
}
}));
```
## Bereitstellungen testen
Sie können einer CDK-Pipeline Schritte hinzufügen, um die von Ihnen durchgeführten Bereitstellungen zu validieren. Sie können beispielsweise die CDK-Pipeline-Bibliotheken verwenden` [ShellStep](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.pipelines.ShellStep.html) `, um Aufgaben wie die folgenden auszuführen:
+ Es wird versucht, auf ein neu bereitgestelltes Amazon API Gateway zuzugreifen, das von einer Lambda-Funktion unterstützt wird
+ Überprüfen einer Einstellung einer bereitgestellten Ressource durch Ausgabe eines AWS CLI-Befehls
In seiner einfachsten Form sieht das Hinzufügen von Validierungsaktionen wie folgt aus:
**Example**
```
// stage was returned by pipeline.addStage
stage.addPost(new ShellStep("validate", {
commands: ['../tests/validate.sh'],
}));
```
```
// stage was returned by pipeline.addStage
stage.addPost(new ShellStep("validate", {
commands: ['../tests/validate.sh'],
}));
```
```
# stage was returned by pipeline.add_stage
stage.add_post(ShellStep("validate",
commands=[''../tests/validate.sh'']
))
```
```
// stage was returned by pipeline.addStage
stage.addPost(ShellStep.Builder.create("validate")
.commands(Arrays.asList("'../tests/validate.sh'"))
.build());
```
```
// stage was returned by pipeline.addStage
stage.AddPost(new ShellStep("validate", new ShellStepProps
{
Commands = new string[] { "'../tests/validate.sh'" }
}));
```
Viele AWS CloudFormation Bereitstellungen führen zur Generierung von Ressourcen mit unvorhersehbaren Namen. Aus diesem Grund bieten CDK Pipelines die Möglichkeit, AWS CloudFormation Ausgaben nach einer Bereitstellung zu lesen. Dadurch ist es möglich, (zum Beispiel) die generierte URL eines Load Balancers an eine Testaktion zu übergeben.
Um Ausgaben zu verwenden, machen Sie das `CfnOutput` Objekt verfügbar, an dem Sie interessiert sind. Übergeben Sie es dann in der `envFromCfnOutputs` Eigenschaft eines Schritts, um es als Umgebungsvariable innerhalb dieses Schritts verfügbar zu machen.
**Example**
```
// given a stack lbStack that exposes a load balancer construct as loadBalancer
this.loadBalancerAddress = new cdk.CfnOutput(lbStack, 'LbAddress', {
value: `https://${lbStack.loadBalancer.loadBalancerDnsName}/`
});
// pass the load balancer address to a shell step
stage.addPost(new ShellStep("lbaddr", {
envFromCfnOutputs: {lb_addr: lbStack.loadBalancerAddress},
commands: ['echo $lb_addr']
}));
```
```
// given a stack lbStack that exposes a load balancer construct as loadBalancer
this.loadBalancerAddress = new cdk.CfnOutput(lbStack, 'LbAddress', {
value: `https://${lbStack.loadBalancer.loadBalancerDnsName}/`
});
// pass the load balancer address to a shell step
stage.addPost(new ShellStep("lbaddr", {
envFromCfnOutputs: {lb_addr: lbStack.loadBalancerAddress},
commands: ['echo $lb_addr']
}));
```
```
# given a stack lb_stack that exposes a load balancer construct as load_balancer
self.load_balancer_address = cdk.CfnOutput(lb_stack, "LbAddress",
value=f"https://{lb_stack.load_balancer.load_balancer_dns_name}/")
# pass the load balancer address to a shell step
stage.add_post(ShellStep("lbaddr",
env_from_cfn_outputs={"lb_addr": lb_stack.load_balancer_address}
commands=["echo $lb_addr"]))
```
```
// given a stack lbStack that exposes a load balancer construct as loadBalancer
loadBalancerAddress = CfnOutput.Builder.create(lbStack, "LbAddress")
.value(String.format("https://%s/",
lbStack.loadBalancer.loadBalancerDnsName))
.build();
stage.addPost(ShellStep.Builder.create("lbaddr")
.envFromCfnOutputs( // Map.of requires Java 9 or later
java.util.Map.of("lbAddr", loadBalancerAddress))
.commands(Arrays.asList("echo $lbAddr"))
.build());
```
```
// given a stack lbStack that exposes a load balancer construct as loadBalancer
loadBalancerAddress = new CfnOutput(lbStack, "LbAddress", new CfnOutputProps
{
Value = string.Format("https://{0}/", lbStack.loadBalancer.LoadBalancerDnsName)
});
stage.AddPost(new ShellStep("lbaddr", new ShellStepProps
{
EnvFromCfnOutputs = new Dictionary
{
{ "lbAddr", loadBalancerAddress }
},
Commands = new string[] { "echo $lbAddr" }
}));
```
Sie können einfache Validierungstests direkt in das schreiben`ShellStep`, aber dieser Ansatz wird unhandlich, wenn der Test mehr als ein paar Zeilen umfasst. Für komplexere Tests können Sie zusätzliche Dateien (z. B. vollständige Shell-Skripte oder Programme in anderen Sprachen) `ShellStep` über die `inputs` Eigenschaft hinzufügen. Bei den Eingaben kann es sich um jeden Schritt handeln, der eine Ausgabe hat, einschließlich einer Quelle (z. B. eines GitHub Repositorys) oder einer anderen`ShellStep`.
Das Importieren von Dateien aus dem Quell-Repository ist angemessen, wenn die Dateien direkt im Test verwendet werden können (z. B. wenn sie selbst ausführbar sind). In diesem Beispiel deklarieren wir unser GitHub Repo als `source` (anstatt es inline als Teil von zu instanziieren). `CodePipeline` Dann übergeben wir diesen Dateisatz sowohl an die Pipeline als auch an den Validierungstest.
**Example**
```
const source = CodePipelineSource.gitHub('OWNER/REPO', 'main');
const pipeline = new CodePipeline(this, 'Pipeline', {
pipelineName: 'MyPipeline',
synth: new ShellStep('Synth', {
input: source,
commands: ['npm ci', 'npm run build', 'npx cdk synth']
})
});
const stage = pipeline.addStage(new MyPipelineAppStage(this, 'test', {
env: { account: '111111111111', region: 'eu-west-1' }
}));
stage.addPost(new ShellStep('validate', {
input: source,
commands: ['sh ../tests/validate.sh']
}));
```
```
const source = CodePipelineSource.gitHub('OWNER/REPO', 'main');
const pipeline = new CodePipeline(this, 'Pipeline', {
pipelineName: 'MyPipeline',
synth: new ShellStep('Synth', {
input: source,
commands: ['npm ci', 'npm run build', 'npx cdk synth']
})
});
const stage = pipeline.addStage(new MyPipelineAppStage(this, 'test', {
env: { account: '111111111111', region: 'eu-west-1' }
}));
stage.addPost(new ShellStep('validate', {
input: source,
commands: ['sh ../tests/validate.sh']
}));
```
```
source = CodePipelineSource.git_hub("OWNER/REPO", "main")
pipeline = CodePipeline(self, "Pipeline",
pipeline_name="MyPipeline",
synth=ShellStep("Synth",
input=source,
commands=["npm install -g aws-cdk",
"python -m pip install -r requirements.txt",
"cdk synth"]))
stage = pipeline.add_stage(MyApplicationStage(self, "test",
env=cdk.Environment(account="111111111111", region="eu-west-1")))
stage.add_post(ShellStep("validate", input=source,
commands=["sh ../tests/validate.sh"],
))
```
```
final CodePipelineSource source = CodePipelineSource.gitHub("OWNER/REPO", "main");
final CodePipeline pipeline = CodePipeline.Builder.create(this, "pipeline")
.pipelineName("MyPipeline")
.synth(ShellStep.Builder.create("Synth")
.input(source)
.commands(Arrays.asList("npm install -g aws-cdk", "cdk synth"))
.build())
.build();
final StageDeployment stage =
pipeline.addStage(new MyPipelineAppStage(this, "test", StageProps.builder()
.env(Environment.builder()
.account("111111111111")
.region("eu-west-1")
.build())
.build()));
stage.addPost(ShellStep.Builder.create("validate")
.input(source)
.commands(Arrays.asList("sh ../tests/validate.sh"))
.build());
```
```
var source = CodePipelineSource.GitHub("OWNER/REPO", "main");
var pipeline = new CodePipeline(this, "pipeline", new CodePipelineProps
{
PipelineName = "MyPipeline",
Synth = new ShellStep("Synth", new ShellStepProps
{
Input = source,
Commands = new string[] { "npm install -g aws-cdk", "cdk synth" }
})
});
var stage = pipeline.AddStage(new MyPipelineAppStage(this, "test", new StageProps
{
Env = new Environment
{
Account = "111111111111", Region = "eu-west-1"
}
}));
stage.AddPost(new ShellStep("validate", new ShellStepProps
{
Input = source,
Commands = new string[] { "sh ../tests/validate.sh" }
}));
```
Das Abrufen der zusätzlichen Dateien aus dem Synth-Schritt ist angemessen, wenn Ihre Tests kompiliert werden müssen, was im Rahmen der Synthese erfolgt.
**Example**
```
const synthStep = new ShellStep('Synth', {
input: CodePipelineSource.gitHub('OWNER/REPO', 'main'),
commands: ['npm ci', 'npm run build', 'npx cdk synth'],
});
const pipeline = new CodePipeline(this, 'Pipeline', {
pipelineName: 'MyPipeline',
synth: synthStep
});
const stage = pipeline.addStage(new MyPipelineAppStage(this, 'test', {
env: { account: '111111111111', region: 'eu-west-1' }
}));
// run a script that was transpiled from TypeScript during synthesis
stage.addPost(new ShellStep('validate', {
input: synthStep,
commands: ['node tests/validate.js']
}));
```
```
const synthStep = new ShellStep('Synth', {
input: CodePipelineSource.gitHub('OWNER/REPO', 'main'),
commands: ['npm ci', 'npm run build', 'npx cdk synth'],
});
const pipeline = new CodePipeline(this, 'Pipeline', {
pipelineName: 'MyPipeline',
synth: synthStep
});
const stage = pipeline.addStage(new MyPipelineAppStage(this, "test", {
env: { account: "111111111111", region: "eu-west-1" }
}));
// run a script that was transpiled from TypeScript during synthesis
stage.addPost(new ShellStep('validate', {
input: synthStep,
commands: ['node tests/validate.js']
}));
```
```
synth_step = ShellStep("Synth",
input=CodePipelineSource.git_hub("OWNER/REPO", "main"),
commands=["npm install -g aws-cdk",
"python -m pip install -r requirements.txt",
"cdk synth"])
pipeline = CodePipeline(self, "Pipeline",
pipeline_name="MyPipeline",
synth=synth_step)
stage = pipeline.add_stage(MyApplicationStage(self, "test",
env=cdk.Environment(account="111111111111", region="eu-west-1")))
# run a script that was compiled during synthesis
stage.add_post(ShellStep("validate",
input=synth_step,
commands=["node test/validate.js"],
))
```
```
final ShellStep synth = ShellStep.Builder.create("Synth")
.input(CodePipelineSource.gitHub("OWNER/REPO", "main"))
.commands(Arrays.asList("npm install -g aws-cdk", "cdk synth"))
.build();
final CodePipeline pipeline = CodePipeline.Builder.create(this, "pipeline")
.pipelineName("MyPipeline")
.synth(synth)
.build();
final StageDeployment stage =
pipeline.addStage(new MyPipelineAppStage(this, "test", StageProps.builder()
.env(Environment.builder()
.account("111111111111")
.region("eu-west-1")
.build())
.build()));
stage.addPost(ShellStep.Builder.create("validate")
.input(synth)
.commands(Arrays.asList("node ./tests/validate.js"))
.build());
```
```
var synth = new ShellStep("Synth", new ShellStepProps
{
Input = CodePipelineSource.GitHub("OWNER/REPO", "main"),
Commands = new string[] { "npm install -g aws-cdk", "cdk synth" }
});
var pipeline = new CodePipeline(this, "pipeline", new CodePipelineProps
{
PipelineName = "MyPipeline",
Synth = synth
});
var stage = pipeline.AddStage(new MyPipelineAppStage(this, "test", new StageProps
{
Env = new Environment
{
Account = "111111111111", Region = "eu-west-1"
}
}));
stage.AddPost(new ShellStep("validate", new ShellStepProps
{
Input = synth,
Commands = new string[] { "node ./tests/validate.js" }
}));
```
## Sicherheitshinweise
Jede Form von Continuous Delivery birgt inhärente Sicherheitsrisiken. Im Rahmen des [Modells der AWS gemeinsamen Verantwortung](https://aws.amazon.com/compliance/shared-responsibility-model/) sind Sie für die Sicherheit Ihrer Informationen in der AWS Cloud verantwortlich. Die CDK-Pipelines-Bibliothek verschafft Ihnen einen Vorsprung, indem sie sichere Standardeinstellungen und bewährte Modellierungsmethoden integriert.
Es liegt jedoch in der Natur der Sache, dass eine Bibliothek, die ein hohes Maß an Zugriff benötigt, um ihren beabsichtigten Zweck zu erfüllen, keine vollständige Sicherheit gewährleisten kann. Es gibt viele Angriffsvektoren außerhalb AWS und Ihres Unternehmens.
Beachten Sie insbesondere Folgendes:
+ Achten Sie auf die Software, auf die Sie angewiesen sind. Prüfen Sie alle Drittanbieter-Software, die Sie in Ihrer Pipeline ausführen, da sie die bereitgestellte Infrastruktur verändern kann.
+ Verwenden Sie das Sperren von Abhängigkeiten, um versehentliche Upgrades zu verhindern. CDK Pipelines respektiert `package-lock.json` und stellt `yarn.lock` sicher, dass Ihre Abhängigkeiten die sind, die Sie erwarten.
+ CDK Pipelines läuft auf Ressourcen, die in Ihrem eigenen Konto erstellt wurden, und die Konfiguration dieser Ressourcen wird von Entwicklern gesteuert, die Code über die Pipeline einreichen. Daher können CDK Pipelines allein nicht vor böswilligen Entwicklern schützen, die versuchen, Konformitätsprüfungen zu umgehen. Wenn Ihr Bedrohungsmodell Entwickler beinhaltet, die CDK-Code schreiben, sollten Sie externe Compliance-Mechanismen wie [AWS CloudFormation Hooks](https://aws.amazon.com/blogs/mt/proactively-keep-resources-secure-and-compliant-with-aws-cloudformation-hooks/) (präventiv) oder [AWS Config](https://aws.amazon.com/config/) (reaktiv) einrichten, zu deren Deaktivierung die AWS CloudFormation Ausführungsrolle nicht berechtigt ist.
+ Anmeldeinformationen für Produktionsumgebungen sollten kurzlebig sein. Nach dem Bootstrapping und der ersten Bereitstellung benötigen Entwickler überhaupt keine Kontoanmeldeinformationen mehr. Änderungen können über die Pipeline bereitgestellt werden. Reduzieren Sie die Wahrscheinlichkeit, dass Anmeldeinformationen durchsickern, indem Sie sie gar nicht erst benötigen.
## Fehlerbehebung
Die folgenden Probleme treten häufig bei den ersten Schritten mit CDK Pipelines auf.
**Pipeline: Interner Fehler**
```
CREATE_FAILED | {aws}::CodePipeline::Pipeline | Pipeline/Pipeline
Internal Failure
```
Überprüfen Sie Ihr GitHub Zugriffstoken. Es fehlt möglicherweise oder verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf das Repository.
**Schlüssel: Die Richtlinie enthält eine Anweisung mit einem oder mehreren ungültigen Prinzipalen**
```
CREATE_FAILED | {aws}::KMS::Key | Pipeline/Pipeline/ArtifactsBucketEncryptionKey
Policy contains a statement with one or more invalid principals.
```
Eine der Zielumgebungen wurde nicht mit dem neuen Bootstrap-Stack gebootet. Stellen Sie sicher, dass alle Ihre Zielumgebungen bootstrapped sind.
**Der Stack befindet sich im Status ROLLBACK\$1COMPLETE und kann nicht aktualisiert werden**
```
Stack is in ROLLBACK_COMPLETE state and cannot be updated. (Service:
AmazonCloudFormation; Status Code: 400; Error Code: ValidationError; Request
ID: ...)
```
Der Stack ist bei der vorherigen Bereitstellung fehlgeschlagen und befindet sich in einem Zustand, der nicht erneut versucht werden kann. Löschen Sie den Stack von der AWS CloudFormation Konsole und wiederholen Sie die Bereitstellung.
# Container-Image-Assets in CDK-Apps erstellen und bereitstellen
Wenn Sie Container-Image-Assets mit dem AWS Cloud Development Kit (AWS CDK) erstellen, wird Docker standardmäßig verwendet, um diese Aktionen auszuführen. Wenn Sie ein anderes Container-Management-Tool verwenden möchten, können Sie Docker durch die `CDK_DOCKER` Umgebungsvariable ersetzen.
## Beispiel: Erstellen und veröffentlichen Sie ein Container-Image-Asset mit dem CDK AWS
Im Folgenden finden Sie ein einfaches Beispiel für eine AWS CDK-App, die standardmäßig Docker verwendet und ein Container-Asset in Amazon Elastic Container Registry (Amazon ECR) erstellt und veröffentlicht:
**Struktur des Projekts**
```
my-cdk-app/
├── lib/
│ ├── my-stack.ts
│ └── docker/
│ ├── Dockerfile
│ └── app/
│ └── index.js
├── bin/
│ └── my-cdk-app.ts
├── package.json
├── tsconfig.json
└── cdk.json
```
**Docker-Datei**
```
FROM public.ecr.aws/lambda/nodejs:16
# Copy application code
COPY app/ /var/task/
# (Optional) Install dependencies
# RUN npm install
# The Lambda Node.js base image looks for index.handler by default
```
**Anwendungscode**
In `lib/docker/app/index.js`:
```
console.log("Hello from inside the container!");
```
**CDK-Stapel**
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as ecr_assets from 'aws-cdk-lib/aws-ecr-assets';
export class MyStack extends cdk.Stack {
constructor(scope: Construct, id: string) {
super(scope, id);
// Define a Docker image asset
const dockerImageAsset = new ecr_assets.DockerImageAsset(this, 'MyDockerImage', {
directory: 'lib/docker', // Path to the directory containing the Dockerfile
});
// Output the ECR URI
new cdk.CfnOutput(this, 'ECRImageUri', {
value: dockerImageAsset.imageUri,
});
}
}
```
**CDK-App**
```
#!/usr/bin/env node
import * as cdk from 'aws-cdk-lib';
import { MyStack } from '../lib/my-stack';
const app = new cdk.App();
new MyStack(app, 'MyStack');
```
Wenn wir es ausführen`cdk deploy`, macht das AWS Cloud Development Kit (AWS CDK) Command Line Interface (CLI) Folgendes:
1. **Das Docker-Image erstellen** — `docker build` Lokal basierend auf dem `Dockerfile` im angegebenen Verzeichnis () `lib/docker` ausführen.
1. **Das Bild kennzeichnen** — Wird ausgeführt`docker tag`, um das erstellte Image mit einem eindeutigen Hash zu versehen, der auf dem Image-Inhalt basiert.
1. In **Amazon ECR veröffentlichen** — Führen Sie diesen Befehl aus`docker push`, um das Container-Image in einem Amazon ECR-Repository zu veröffentlichen. Dieses Repository muss bereits existieren. Es wird während des Standard-Bootstrapping-Vorgangs erstellt.
1. **Image-URI ausgeben** — Nach einer erfolgreichen Bereitstellung wird der Amazon ECR-URI des veröffentlichten Container-Images in Ihrer Befehlszeile ausgegeben. Dies ist der URI unseres Docker-Images in Amazon ECR.
## Wie ersetzt man Docker durch ein anderes Container-Management-Tool
Verwenden Sie die `CDK_DOCKER` Umgebungsvariable, um den Pfad zur Binärdatei Ihres Ersatz-Container-Management-Tools anzugeben. Im Folgenden finden Sie ein Beispiel für das Ersetzen von Docker durch Finch:
```
$ which finch
/usr/local/bin/finch # Locate the path to the binary
$ export CDK_DOCKER='/usr/local/bin/finch' # Set the environment variable
$ cdk deploy # Deploy using the replacement
```
Aliasing oder Verlinkung werden nicht unterstützt. Um Docker zu ersetzen, müssen Sie die `CDK_DOCKER` Umgebungsvariable verwenden.
## Unterstützte Drop-In-Ersatz-Engines für Docker
Finch wird unterstützt, obwohl einige Docker-Funktionen möglicherweise nicht verfügbar sind oder im Zuge der Weiterentwicklung des Tools anders funktionieren. Weitere Informationen zu Finch finden Sie unter [Ready for Flight: Ankündigung](https://aws.amazon.com/blogs/opensource/ready-for-flight-announcing-finch-1-0-ga/) von Finch 1.0 GA\$1 im * AWS Open-Source-Blog*.
Andere Tools zur Containerverwaltung funktionieren möglicherweise. Das CDK überprüft nicht, welchen Docker-Ersatz Sie verwenden, um festzustellen, ob er unterstützt wird. Wenn das Tool äquivalente Docker-Befehle hat und sich ähnlich verhält, sollte es funktionieren.
# Problembehandlung bei AWS CDK-Bereitstellungen
Beheben Sie häufig auftretende Probleme bei der Bereitstellung von AWS Cloud Development Kit (AWS CDK) -Anwendungen.
## Bei der Bereitstellung werden falsche Dienstprinzipale erstellt
Bei der Bereitstellung von CDK-Anwendungen, die AWS Identity and Access Management (IAM) -Rollen mit Dienstprinzipalen enthalten, stellen Sie fest, dass falsche Domänen für die Dienstprinzipale erstellt werden.
Im Folgenden finden Sie ein grundlegendes Beispiel für die Erstellung einer IAM-Rolle, die von Amazon CloudWatch Logs mithilfe ihres Service-Principals übernommen werden kann:
```
import * as cdk from 'aws-cdk-lib';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';
export class MyCdkProjectStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Create an IAM role for CloudWatch Logs to assume
const cloudWatchLogsRole = new iam.Role(this, 'CloudWatchLogsRole', {
assumedBy: new iam.ServicePrincipal('logs.amazonaws.com'), // This is for CloudWatch Logs
managedPolicies: [
iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSCloudWatchLogsFullAccess')
]
});
// You can then use this role in other constructs or configurations where CloudWatch Logs needs to assume a role
}
}
```
Wenn Sie diesen Stack bereitstellen, `logs.amazonaws.com` sollte ein Dienstprinzipal mit dem Namen erstellt werden. In den meisten Fällen verwenden AWS Dienste die folgende Benennung für Dienstprinzipale:`.amazonaws.com`.
### Häufige Ursachen
Wenn Sie eine Version des AWS CDK verwenden, die älter als v2.150.0 ist, kann dieser Fehler auftreten. In älteren AWS CDK-Versionen war die Benennung von Service Principals nicht standardisiert, was zur Erstellung von Service Principals mit falschen Domains führen konnte.
In AWS CDK v2.51.0 wurde ein Fix implementiert, indem alle automatisch erstellten Service Principals standardisiert wurden, sodass sie nach Möglichkeit verwendet werden. `.amazonaws.com` Dieser Fix war verfügbar, indem das Feature-Flag zugelassen wurde. `@aws-cdk/aws-iam:standardizedServicePrincipals`
Ab AWS CDK v2.150.0 wurde dies zum Standardverhalten.
### Auflösung
Führen Sie ein Upgrade auf AWS CDK v2.150.0 oder neuer durch.
Wenn Sie kein Upgrade auf AWS CDK v2.150.0 oder neuer durchführen können, müssen Sie ein Upgrade auf mindestens v2.51.0 oder neuer durchführen. Lassen Sie dann das folgende Feature-Flag in Ihrer Datei zu:. `cdk.json` `@aws-cdk/aws-iam:standardizedServicePrincipals`