Erste Schritte mit AWS CDK

HANDBUCH "ERSTE SCHRITTE"

Modul 3: Erstellen Ihres ersten AWS-CDK-Projekts

In diesem Modul werden Sie mit dem AWS Cloud Development Kit (CDK) eine Infrastruktur erstellen.

Einführung

In dieser Anleitung verwenden wir die AWS CDK CLI, um ein neues Infrastrukturprojekt mit TypeScript zu erstellen. Wir werden auch lernen, wie man eine einfache Ressource schreibt und wie man den eigenen CDK-Code synthetisieren und einsetzen kann. Durch die Synthese wandelt CDK Ihren Infrastrukturcode in AWS-CloudFormation-Vorlagen um.

Lerninhalte

  • Erstellen eines neuen CDK-Projekts mit TypeScript.
  • Schreiben einer einfachen Ressource in CDK (VPC).
  • Synthese Ihres CDK-Codes in eine CloudFormation-Vorlage.
  • Bereitstellen der Infrastruktur in Ihrem AWS-Konto.

 Veranschlagte Zeit

15 Minuten

 Voraussetzungen für das Modul

  • AWS-Konto mit Administratorzugriff**
  • Empfohlener Browser: aktuelle Version von Chrome oder Firefox

[**]Innerhalb der letzten 24 Stunden erstellte Konten haben möglicherweise noch keinen Zugriff auf alle für dieses Tutorial erforderlichen Services.

Implementierung

Erstellen Sie ein neues CDK-Projekt

Um ein neues CDK-Projekt zu erstellen, benutzen wir die CDK CLI. Um zu beginnen, erstellen Sie ein leeres Verzeichnis auf Ihrem System und wechseln Sie in dieses Verzeichnis. Nun werden wir cdk init verwenden, um ein neues TypeScript-CDK-Projekt zu erstellen:

mkdir cdk-demo
cd cdk-demo
cdk init --language typescript

Dadurch wird die Ordnerstruktur erstellt und einige der für ein TypeScript-CDK-Projekt erforderlichen Module installiert. Ihre Ausgabe sollte in etwa so aussehen:

Applying project template app for typescript
# Welcome to your CDK TypeScript project!

This is a blank project for TypeScript development with CDK.

The `cdk.json` file tells the CDK Toolkit how to execute your app.

## Useful commands

 * `npm run build`   compile typescript to js
 * `npm run watch`   watch for changes and compile
 * `npm run test`    perform the jest unit tests
 * `cdk deploy`      deploy this stack to your default AWS account/region
 * `cdk diff`        compare deployed stack with current state
 * `cdk synth`       emits the synthesized CloudFormation template

Initializing a new git repository...
Executing npm install...
npm WARN deprecated urix@0.1.0: Please see https://github.com/lydell/urix#deprecated
npm WARN deprecated resolve-url@0.2.1: https://github.com/lydell/resolve-url#deprecated
npm WARN deprecated sane@4.1.0: some dependency vulnerabilities fixed, support for node < 10 dropped, and newer ECMAScript syntax/features added
npm notice
npm notice New minor version of npm available! 7.19.0 -> 7.20.1
npm notice Changelog: https://github.com/npm/cli/releases/tag/v7.20.1
npm notice Run npm install -g npm@7.20.1 to update!
npm notice
✅ All done!

Es stellt Ihnen auch die Befehle zur Verfügung, die Sie benötigen, um mit Ihrem CDK-Projekt zu beginnen. Wir sind nun bereit, unseren ersten CDK-Code, um eine Infrastruktur zu schaffen, zu schreiben.

Infrastruktur schaffen

Ein gängiger Ausgangspunkt für den Aufbau eines Projekts ist die Erstellung eines von Ihnen definierten, logisch isolierten virtuellen Netzwerks, einer sogenannten Amazon Virtual Private Cloud (VPC). Bevor wir unsere erste VPC erstellen, müssen wir die Dateien verstehen, die der Befehl cdk init erstellt hat.

Erstellen und Bereitstellen Ihrer CDK-Anwendung

├── bin
│   └── cdk-demo.ts
├── cdk.json
├── jest.config.js
├── lib
│   └── cdk-demo-stack.ts
├── package.json
├── package-lock.json
├── README.md
├── test
│   └── cdk-demo.test.ts
└── tsconfig.json

Hier sind einige der wichtigen Dateien und wofür sie verwendet werden:

  • bin/cdk-project.ts - Dies ist der Einstiegspunkt zu Ihrer CDK-Anwendung. Dadurch werden alle Stacks, die wir unter lib/* definieren, geladen/erzeugt.
  • lib/cdk-project-stack.ts - Hier wird Ihr Haupt-CDK-Anwendungsstack definiert. Ihre Ressourcen und deren Eigenschaften können hier abgelegt werden.
  • package.json - Hier definieren Sie Ihre Projektabhängigkeiten sowie einige zusätzliche Informationen und Build-Skripte (npm build, npm test, npm watch).
  • cdk.json - Diese Datei teilt dem Toolkit mit, wie Ihre Anwendung auszuführen ist, sowie einige zusätzliche Einstellungen und Parameter in Bezug auf CDK und Ihr Projekt.

In dieser Anleitung werden wir uns auf die Dateien lib/cdk-demo.ts und bin/cdk-demo.ts konzentrieren, um unsere Infrastruktur aufzubauen. Fügen wir etwas Code hinzu.

Einige Dinge in unserer Anwendung definieren

Bevor wir unsere VPC im Hauptstack definieren, müssen wir sicherstellen, dass wir für das richtige Konto und die richtige Region bereitstellen. Auch wenn das CDK diese Informationen aus Ihrer lokalen aws-cli-Konfiguration bezieht, ist es am besten, dies manuell in Ihrem CDK-Code zu konfigurieren, um falsche Werte zu vermeiden, wenn sich diese Konfiguration ändert. Für diesen Leitfaden ist sie aufgrund der Einstellungen, die wir in unserer VPC vornehmen werden, erforderlich. Wenn Sie dies nicht angeben, ist der Stack zwar umgebungsunabhängig, aber einige Funktionen und Kontextsuchen funktionieren nicht. Weitere Informationen finden Sie unter Umgebungen in der Dokumentation.

Ändern Sie Ihren bin/cdk-demo.ts Stack so, dass er etwa so aussieht. Stellen Sie sicher, dass Sie Ihre AWS-Konto-ID durch die richtige Nummer ersetzen und die richtige Region auswählen. Wir empfehlen, für diesen Leitfaden entweder us-east-1 oder eu-west-1 zu wählen.

#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from '@aws-cdk/core';
import { CdkDemoStack } from '../lib/cdk-demo-stack';

const app = new cdk.App();
new CdkDemoStack(app, 'CdkDemoStack', {
  env: { account: '123456789012', region: 'eu-west-1' },

});

Jetzt sind Sie bereit, Ihre erste Ressource zu schreiben.

Code für die VPC

Wir werden eine VPC mit zwei öffentlichen Subnetzen erstellen, die sich auf zwei Availability Zones verteilen. Bevor wir mit dem Schreiben des Codes beginnen können, müssen wir die Module der Konstruktionsbibliothek erklären und installieren. Die verschiedenen Dienste sind in Modulen zusammengefasst, damit Sie nur die Abhängigkeiten hinzufügen müssen, die Sie für die von Ihnen bereitgestellte Infrastruktur benötigen. Module können entweder für einen einzelnen Service, z.B. AWS Amplify, oder für mehrere Services, z.B. Amazon EC2, sein. Für diese Anleitung benötigen wir das Amazon-EC2-Modul, das auch Unterstützung für AWS VPCs bietet.

Zur Installation Ihres Moduls werden wir npm verwenden. Führen Sie den folgenden Befehl aus, während Sie sich in Ihrem Projektverzeichnis befinden:

npm install @aws-cdk/aws-ec2

Dadurch werden alle notwendigen Module, mit denen wir arbeiten, installiert. Wenn Sie in Ihrer package.json nachsehen, werden Sie sehen, dass es auch dort hinzugefügt wurde.

Jetzt sind wir bereit, unsere VPC zu erstellen. Öffnen Sie Ihre Stack-Definition in lib/cdk-demo.ts. Wenn Sie die Datei zum ersten Mal öffnen, sollten Sie so etwas sehen:

import * as cdk from '@aws-cdk/core';

export class CdkDemoStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // The code that defines your stack goes here
  }
}

Dies ist das Grundgerüst unseres Projekts. Wenn Sie CDK jetzt ausführen würden, würden keine Ressourcen erstellt, da wir noch keine definiert haben. Um mit dem VPC zu beginnen, müssen wir das installierte Modul importieren und die darin enthaltenen Code-Module referenzieren - wir werden die Vpc- und die SubnetType-Klasse importieren.

import * as cdk from '@aws-cdk/core';

// CHANGE: This is where you import the classes from the module:
import { Vpc, SubnetType } from '@aws-cdk/aws-ec2';

export class CdkDemoStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // The code that defines your stack goes here
  }
}

Bei der Erstellung einer VPC gibt es eine Reihe von Eigenschaften, die wir einstellen können, um sie an unsere Bedürfnisse anzupassen. Standardmäßig wird eine VPC über 3 Availability Zones (AZs) erstellt, mit öffentlichen und privaten Subnetzen (mit einem einzigen Internet Gateway und 3 NAT Gateways). In dieser Anleitung wollen wir nur eine sehr einfache Einrichtung erstellen, die sich über 2 AZs erstreckt, und zwar mit einem öffentlichen Subnetz für jedes. Bitte lesen Sie dieses Dokument, um eine genauere Erklärung der Unterschiede zu erhalten. 

Um unsere VPC zu erstellen, geben wir zwei AZs und die Details zur Erstellung eines öffentlichen Subnetzes an (siehe unten):

import * as cdk from '@aws-cdk/core';
import { Vpc, SubnetType } from '@aws-cdk/aws-ec2';

export class CdkDemoStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // The code that defines your stack goes here
    // CHANGE: We have created the vpc object from the Vpc class.
    const vpc = new Vpc(this, 'MainVpc',{
    
    // CHANGE: this is where we define how many AZs to use
    maxAzs: 2,
      
   // CHANGE: We define a single subnet configuration per AZ.
      subnetConfiguration:  [
        {
          // CHANGE: this is it's CIDR mask so 255.255.255.0
          cidrMask: 24,

          // CHANGE: a name for each of these subnets
          name: 'public-subnet',

          // CHANGE: and the subnet type to be used - here we will have
          // a public subnet. There are other options available here.
          subnetType: SubnetType.PUBLIC
        },
      ]
    });
  }
}

Wir sind nun bereit, diese Infrastrukturänderung auf unserem Konto zu implementieren.

Bereitstellungszeit

Zeit, unsere Bereitstellung zu testen. Um zu sehen, ob Ihr Code gültig ist, können Sie npm build ausführen, welches TypeScript in JavaScript kompiliert. Wenn dies erfolgreich war, können Sie den Bereitstellungsbefehl ausführen:

cdk deploy

Dadurch wird Ihr TypeScript in JavaScript kompiliert und ein CloudFormation-Änderungssatz zur Bereitstellung dieser Änderung erstellt. CDK verwaltet all dies für Sie, ebenso wie das Hochladen der Vorlagendatei auf S3 und das Verwenden von CloudFormation zur Ausführung. Sie sollten eine ähnliche Ausgabe wie unten sehen:

# cdk deploy
CdkDemoStack: deploying...
CdkDemoStack: creating CloudFormation changeset...
[··························································] (0/13)

3:50:17 PM | CREATE_IN_PROGRESS   | AWS::CloudFormation::Stack            | CdkDemoStack
3:50:21 PM | CREATE_IN_PROGRESS   | AWS::EC2::InternetGateway             | MainVpc/IGW
3:50:21 PM | CREATE_IN_PROGRESS   | AWS::EC2::VPC                         | MainVpc
3:50:22 PM | CREATE_IN_PROGRESS   | AWS::CDK::Metadata                    | CDKMetadata/Default

Nach ein paar Minuten sollten Sie ein grünes Häkchen zusammen mit einem ARN (Amazon Resource Name) Ihres neu erstellten CloudFormation-Stacks erhalten. Ihre neue VPC ist nun eingerichtet und kann benutzt werden.

Ressourcen reinigen (optional)

Die in dieser Anleitung erstellte VPC kostet nichts pro Monat, aber es gibt ein Kontingent, das für jede Region in einem Konto nur 5 VPCs zulässt - Sie können dieses Limit bei Bedarf durch ein Support-Ticket erhöhen. Wenn Sie Ihre neu erstellten Ressourcen wieder entfernen möchten, können Sie den Befehl cdk destroy ausführen, der alle Ressourcen über den zuvor erstellten CloudFormation-Stack entfernt.

cdk destroy

Sie sollten die folgende Aufforderung erhalten. Nachdem Sie y und enter gedrückt haben, beginnt das Programm mit der Entfernung der gesamten Infrastruktur und stellt Updates bereit. Sobald Sie fertig sind, sehen Sie Folgendes:

Are you sure you want to delete: CdkEcsInfraStack (y/n)? y
CdkEcsInfraStack: destroying...

✅  CdkEcsInfraStack: destroyed

Abschluss

Herzlichen Glückwunsch! Sie haben denErste Schritte mit AWS CDK Leitfaden abgeschlossen. In dieser Anleitung haben wir unser erstes AWS-CDK-Projekt in TypeScript erstellt, indem wir eine VPC erstellt haben. Wir haben besprochen, wie Sie ein neues CDK-Projekt initialisieren und damit diese Infrastruktur erstellen. Dieser CDK-Code und VPC werden in zukünftigen Leitfäden verwendet. Wir empfehlen Ihnen, sich den Leitfaden für die Bereitstellung Ihrer ersten Webanwendung anzusehen. 

Wenn Sie tiefer in Konzepte wie Ordnerstrukturen, Konstrukte, Stacks und Anwendungen eintauchen möchten, empfehlen wir Ihnen, die Dokumentation zu lesen. 

Lassen Sie uns wissen, wie wir abgeschnitten haben.

Vielen Dank für Ihr Feedback
Wir freuen uns, dass diese Seite Ihnen geholfen hat. Würden Sie uns weitere Details mitteilen, damit wir uns weiter verbessern können?
Schließen
Vielen Dank für Ihr Feedback
Es tut uns leid, dass diese Seite Ihnen nicht weiterhelfen konnte. Würden Sie uns weitere Details mitteilen, damit wir uns weiter verbessern können?
Schließen