Voraussetzungen Über dieses Tutorial Schritt 1: Erstellen Sie Ihr CDK Projekt Schritt 2: Konfigurieren Sie Ihre AWS Umgebung Schritt 3: Bootstrap für Ihre Umgebung AWS Schritt 4: Erstellen Sie Ihre App CDK Schritt 5: Listet die CDK Stapel in eurer App auf Schritt 6: Definieren Sie Ihre Lambda-Funktion Schritt 7: Definieren Sie Ihre Lambda-Funktion URL Schritt 8: Synthetisieren Sie eine Vorlage CloudFormation Schritt 9: Stellen Sie Ihren Stack bereit CDK Schritt 10: Interagieren Sie mit Ihrer Anwendung auf AWS Schritt 11: Ändern Sie Ihre Anwendung Schritt 12: Löschen Sie Ihre Bewerbung Nächste Schritte

Tutorial: Erstelle deine erste AWS CDK App

Beginnen Sie mit der Verwendung AWS Cloud Development Kit (AWS CDK) von mithilfe der AWS CDK Befehlszeilenschnittstelle (AWS CDK CLI), um Ihre erste CDK App zu entwickeln, Ihre AWS Umgebung zu booten und Ihre Anwendung darauf AWS bereitzustellen.

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, führen Sie alle Einrichtungsschritte unter durch. Erste Schritte mit dem AWS CDK

Über dieses Tutorial

In diesem Tutorial erstellen und implementieren Sie eine einfache Anwendung AWS mithilfe von AWS CDK. Die Anwendung besteht aus einer AWS Lambda Funktion, die beim Aufruf eine Hello World! Nachricht zurückgibt. Die Funktion wird über eine Lambda-Funktion aufgerufenURL, die als dedizierter HTTP (S) -Endpunkt für Ihre Lambda-Funktion dient.

In diesem Tutorial werden Sie Folgendes ausführen:

Erstellen Sie Ihr Projekt — Erstellen Sie ein CDK Projekt mit dem CDK CLI cdk initBefehl.
Konfiguration Ihrer AWS Umgebung — Konfigurieren Sie die AWS Umgebung, in der Sie Ihre Anwendung bereitstellen werden.
Bootstrapping für Ihre AWS Umgebung — Bereiten Sie Ihre AWS Umgebung auf die Bereitstellung vor, indem Sie sie mithilfe des CDK CLI cdk bootstrapBefehl.
Entwickeln Sie Ihre App — Verwenden Sie Konstrukte aus der AWS Construct-Bibliothek, um Ihre Lambda-Funktion und Lambda-Funktionsressourcen zu definieren. URL
Bereiten Sie Ihre App für die Bereitstellung vor — Verwenden Sie CDK CLI um Ihre App zu erstellen und eine AWS CloudFormation Vorlage zu synthetisieren.
Stellen Sie Ihre App bereit — Verwenden Sie CDK CLI cdk deployBefehl, um Ihre Anwendung bereitzustellen und Ihre AWS Ressourcen bereitzustellen.
Interagieren Sie mit Ihrer Anwendung — Interagieren Sie mit Ihrer bereitgestellten Lambda-Funktion, AWS indem Sie sie aufrufen und eine Antwort erhalten.
Ändern Sie Ihre App — Ändern Sie Ihre Lambda-Funktion und stellen Sie sie bereit, um Ihre Änderungen zu implementieren.
Löschen Sie Ihre App — Löschen Sie alle Ressourcen, die Sie mit dem erstellt haben CDK CLI cdk destroyBefehl.

Schritt 1: Erstellen Sie Ihr CDK Projekt

In diesem Schritt erstellen Sie ein neues CDK Projekt. Ein CDK Projekt sollte sich in einem eigenen Verzeichnis mit eigenen lokalen Modulabhängigkeiten befinden.

Um ein CDK Projekt zu erstellen

Erstellen Sie von einem Startverzeichnis Ihrer Wahl aus ein Verzeichnis mit dem Namenhello-cdk:
```
$ mkdir hello-cdk && cd hello-cdk
```
Wichtig
Achten Sie darauf, dass Sie Ihr Projektverzeichnis genau so benennenhello-cdk, wie hier gezeigt. Das CDK CLI verwendet diesen Verzeichnisnamen, um Dinge in Ihrem CDK Code zu benennen. Wenn Sie einen anderen Verzeichnisnamen verwenden, werden Sie in diesem Tutorial auf Probleme stoßen.
Initialisieren Sie im hello-cdk Verzeichnis ein neues CDK Projekt mit dem CDK CLI cdk initBefehl. Geben Sie die app Vorlage und Ihre bevorzugte Programmiersprache mit der --language Option an:
TypeScript
```
$ cdk init app --language typescript
```
JavaScript
```
$ cdk init app --language javascript
```
Python
```
$ cdk init app --language python
```
Nachdem die App erstellt wurde, geben Sie auch die folgenden beiden Befehle ein. Diese aktivieren die der App Python virtuelle Umgebung und installiert die AWS CDK Kernabhängigkeiten.
```
$ source .venv/bin/activate # On Windows, run `.\venv\Scripts\activate` instead
$ python -m pip install -r requirements.txt
```
Java
```
$ cdk init app --language java
```
Wenn Sie eine verwendenIDE, können Sie das Projekt jetzt öffnen oder importieren. In Eclipse, wählen Sie beispielsweise „Datei“ > „Importieren“ > „Maven“ > „Bestehende Maven-Projekte“. Stellen Sie sicher, dass die Projekteinstellungen so eingestellt sind, dass sie Java 8 (1.8) verwenden.
C#
```
$ cdk init app --language csharp
```
Wenn Sie Visual Studio verwenden, öffnen Sie die Lösungsdatei im src Verzeichnis.
Go
```
$ 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
```

Der cdk init Befehl erstellt eine Struktur von Dateien und Ordnern innerhalb des hello-cdk Verzeichnisses, um den Quellcode für Ihre CDK App zu organisieren. Diese Struktur von Dateien und Ordnern wird Ihr CDK Projekt genannt. Nehmen Sie sich einen Moment Zeit, um Ihr CDK Projekt zu erkunden.

Wenn du Git installiert, cdk init wird jedes Projekt, mit dem Sie erstellen, auch als initialisiert Git Repository.

Während der Projektinitialisierung CDK CLI erstellt eine CDK App, die einen einzelnen CDK Stapel enthält. Die CDK App-Instanz wird mit dem App Konstrukt erstellt. Im Folgenden finden Sie einen Teil dieses Codes aus Ihrer CDK Anwendungsdatei:

TypeScript

Befindet sich inbin/hello-cdk.ts:


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

const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
});

JavaScript

Befindet sich inbin/hello-cdk.js:


#!/usr/bin/env node

const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');

const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
});

Python

Befindet sich inapp.py:


#!/usr/bin/env python3
import os

import aws_cdk as cdk

from hello_cdk.hello_cdk_stack import HelloCdkStack


app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",)

app.synth()

Java

Befindet sich insrc/main/java/.../HelloCdkApp.java:


package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;

import java.util.Arrays;

public class HelloCdkApp {
  public static void main(final String[] args) {
    App app = new App();

    new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
      .build());

    app.synth();
  }
}

C#

Befindet sich insrc/HelloCdk/Program.cs:


using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;

namespace HelloCdk
{
  sealed class Program
  {
    public static void Main(string[] args)
    {
      var app = new App();
      new HelloCdkStack(app, "HelloCdkStack", new StackProps
      {});
      app.Synth();
    }
  }
}

Go

Befindet sich inhello-cdk.go:


package main

import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/constructs-go/constructs/v10"
  "github.com/aws/jsii-runtime-go"
)

// ...

func main() {
  defer jsii.Close()

  app := awscdk.NewApp(nil)

  NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
    awscdk.StackProps{
      Env: env(),
    },
  })

  app.Synth(nil)
}

// ...

Der CDK Stapel wird mit dem Stack Konstrukt erstellt. Im Folgenden finden Sie einen Teil dieses Codes aus Ihrer CDK Stack-Datei:

TypeScript

Befindet sich inlib/hello-cdk-stack.ts:


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class HelloCdkStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    
    // Define your constructs here

  }
}

JavaScript

Befindet sich inlib/hello-cdk-stack.js:


const { Stack } = require('aws-cdk-lib');

class HelloCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define your constructs here

  }
}

module.exports = { HelloCdkStack }

Python

Befindet sich inhello_cdk/hello_cdk_stack.py:


from aws_cdk import (
  Stack,
)
from constructs import Construct

class HelloCdkStack(Stack):

  def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
    super().__init__(scope, construct_id, **kwargs)

    # Define your constructs here

Java

Befindet sich insrc/main/java/.../HelloCdkStack.java:


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;

public class HelloCdkStack extends Stack {
  public HelloCdkStack(final Construct scope, final String id) {
    this(scope, id, null);
  }

  public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
    super(scope, id, props);

    // Define your constructs here
  }
}

C#

Befindet sich insrc/HelloCdk/HelloCdkStack.cs:


using Amazon.CDK;
using Constructs;

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define your constructs here
    }
  }
}

Go

Befindet sich inhello-cdk.go:


package main

import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/constructs-go/constructs/v10"
  "github.com/aws/jsii-runtime-go"
)

type HelloCdkStackProps struct {
  awscdk.StackProps
}

func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
  var sprops awscdk.StackProps
  if props != nil {
    sprops = props.StackProps
  }
  stack := awscdk.NewStack(scope, &id, &sprops)

  return stack
}

// ...

Schritt 2: Konfigurieren Sie Ihre AWS Umgebung

In diesem Schritt konfigurieren Sie die AWS Umgebung für Ihren CDK Stack. Auf diese Weise geben Sie an, in welcher Umgebung Ihr CDK Stack bereitgestellt wird.

Bestimmen Sie zunächst die AWS Umgebung, die Sie verwenden möchten. Eine AWS Umgebung besteht aus einem AWS-Konto und AWS-Region.

Wenn Sie die verwenden AWS CLI , um Sicherheitsanmeldeinformationen auf Ihrem lokalen Computer zu konfigurieren, können Sie die dann verwenden, AWS CLI um AWS Umgebungsinformationen für ein bestimmtes Profil abzurufen.

Um das zu verwenden AWS CLI , um Ihre AWS-Konto ID zu erhalten

Führen Sie den folgenden AWS CLI Befehl aus, um die AWS-Konto ID für Ihr default Profil abzurufen:
```
$ aws sts get-caller-identity --query "Account" --output text
```
Wenn Sie lieber ein benanntes Profil verwenden möchten, geben Sie den Namen Ihres Profils mit der --profile Option an:
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```

Um das AWS CLI zu verwenden, um Ihr AWS-Region

Führen Sie den folgenden AWS CLI Befehl aus, um die Region abzurufen, die Sie für Ihr default Profil konfiguriert haben:
```
$ aws configure get region
```
Wenn Sie lieber ein benanntes Profil verwenden möchten, geben Sie den Namen Ihres Profils mit der folgenden --profile Option an:
```
$ aws configure get region --profile your-profile-name
```

Als Nächstes konfigurieren Sie die AWS Umgebung für Ihren CDK Stack, indem Sie die HelloCdkStack Instanz in Ihrer Anwendungsdatei ändern. Für dieses Tutorial werden Sie Ihre AWS Umgebungsinformationen fest codieren. Dies wird für Produktionsumgebungen empfohlen. Informationen zu anderen Möglichkeiten zur Konfiguration von Umgebungen finden Sie unterKonfigurieren Sie Umgebungen für die Verwendung mit dem AWS CDK.

So konfigurieren Sie die Umgebung für Ihren CDK Stack

Verwenden Sie in Ihrer Anwendungsdatei die env Eigenschaft des Stack Konstrukts, um Ihre Umgebung zu konfigurieren. Im Folgenden wird ein Beispiel gezeigt:

TypeScript

Befindet sich inbin/hello-cdk.ts:


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

const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
  env: { account: '123456789012', region: 'us-east-1' },
});

JavaScript

Befindet sich inbin/hello-cdk.js:


#!/usr/bin/env node

const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');

const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
  env: { account: '123456789012', region: 'us-east-1' },
});

Python

Befindet sich inapp.py:


#!/usr/bin/env python3
import os

import aws_cdk as cdk

from hello_cdk.hello_cdk_stack import HelloCdkStack


app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",
  env=cdk.Environment(account='123456789012', region='us-east-1'),
  )
  
app.synth()

Java

Befindet sich insrc/main/java/.../HelloCdkApp.java:


package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;

import java.util.Arrays;

public class HelloCdkApp {
    public static void main(final String[] args) {
        App app = new App();

        new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
                .env(Environment.builder()
                        .account("123456789012")
                        .region("us-east-1")
                        .build())

                .build());

        app.synth();
    }
}

C#

Befindet sich insrc/HelloCdk/Program.cs:


using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;

namespace HelloCdk
{
    sealed class Program
    {
        public static void Main(string[] args)
        {
            var app = new App();
            new HelloCdkStack(app, "HelloCdkStack", new StackProps
            {
                Env = new Amazon.CDK.Environment
                {
                    Account = "123456789012",
                    Region = "us-east-1",
                }
            });
            app.Synth();
        }
    }
}

Go

Befindet sich inhello-cdk.go:


package main

import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/constructs-go/constructs/v10"
  "github.com/aws/jsii-runtime-go"
)

// ...

func main() {
  defer jsii.Close()

  app := awscdk.NewApp(nil)

  NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
    awscdk.StackProps{
      Env: env(),
    },
  })

  app.Synth(nil)
}

func env() *awscdk.Environment {
	return &awscdk.Environment{
		Account: jsii.String("123456789012"),
		Region:  jsii.String("us-east-1"),
	}
}

Schritt 3: Bootstrap für Ihre Umgebung AWS

In diesem Schritt booten Sie die AWS Umgebung, die Sie im vorherigen Schritt konfiguriert haben. Dadurch wird Ihre Umgebung auf CDK Bereitstellungen vorbereitet.

Um Ihre Umgebung zu booten, führen Sie im Stammverzeichnis Ihres CDK Projekts Folgendes aus:


$ cdk bootstrap

Wenn Sie das Bootstrapping vom Stammverzeichnis Ihres CDK Projekts aus durchführen, müssen Sie keine zusätzlichen Informationen angeben. Das CDK CLI bezieht Umgebungsinformationen aus Ihrem Projekt. Wenn Sie außerhalb eines CDK Projekts booten, müssen Sie Umgebungsinformationen zusammen mit dem cdk bootstrap Befehl angeben. Weitere Informationen finden Sie unter Bootstrap Ihre Umgebung für die Verwendung mit AWS CDK.

Schritt 4: Erstellen Sie Ihre App CDK

In den meisten Programmierumgebungen erstellen oder kompilieren Sie Code, nachdem Sie Änderungen vorgenommen haben. Dies ist bei der nicht erforderlich, AWS CDK da CDK CLI führt diesen Schritt automatisch aus. Sie können jedoch immer noch manuell bauen, wenn Sie Syntax- und Typfehler abfangen möchten. Im Folgenden wird ein Beispiel gezeigt:

Schritt 5: Listet die CDK Stapel in eurer App auf

Zu diesem Zeitpunkt sollten Sie eine CDK App haben, die einen einzigen CDK Stapel enthält. Verwenden Sie zur Überprüfung den CDK CLI cdk listBefehl zum Anzeigen Ihrer Stapel. Die Ausgabe sollte einen einzelnen Stapel mit dem Namen HelloCdkStack anzeigen:


$ cdk list
HelloCdkStack

Wenn Sie diese Ausgabe nicht sehen, stellen Sie sicher, dass Sie sich im richtigen Arbeitsverzeichnis Ihres Projekts befinden, und versuchen Sie es erneut. Wenn Sie Ihren Stack immer noch nicht sehen, wiederholen Sie den Vorgang Schritt 1: Erstellen Sie Ihr CDK Projekt und versuchen Sie es erneut.

Schritt 6: Definieren Sie Ihre Lambda-Funktion

In diesem Schritt importieren Sie das aws_lambda Modul aus der Construct-Bibliothek und verwenden das AWS Function L2-Konstrukt.

Ändern Sie Ihre CDK Stack-Datei wie folgt:

TypeScript

Befindet sich inlib/hello-cdk-stack.ts:


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import the Lambda module
import * as lambda from 'aws-cdk-lib/aws-lambda';

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

    // Define the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };
      `),
    });
  }
}

JavaScript

Befindet sich inlib/hello-cdk-stack.js:


const { Stack } = require('aws-cdk-lib');
// Import the Lambda module
const lambda = require('aws-cdk-lib/aws-lambda');

class HelloCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };
      `),
    });

  }
}

module.exports = { HelloCdkStack }

Python

Befindet sich inhello_cdk/hello_cdk_stack.py:


from aws_cdk import (
  Stack,
  aws_lambda as _lambda, # Import the Lambda module
)
from constructs import Construct

class HelloCdkStack(Stack):

  def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
    super().__init__(scope, construct_id, **kwargs)

    # Define the Lambda function resource
    my_function = _lambda.Function(
      self, "HelloWorldFunction", 
      runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
      handler = "index.handler",
      code = _lambda.Code.from_inline(
        """
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };
        """
      ),
    )

Java

Befindet sich insrc/main/java/.../HelloCdkStack.java:


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
// Import Lambda function
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;

public class HelloCdkStack extends Stack {
  public HelloCdkStack(final Construct scope, final String id) {
    this(scope, id, null);
  }

  public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
    super(scope, id, props);

    // Define the Lambda function resource
    Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
      .runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
      .handler("index.handler")
      .code(Code.fromInline(
        "exports.handler = async function(event) {" +
        " return {" +
        " statusCode: 200," +
        " body: JSON.stringify('Hello World!')" +
        " };" +
        "};"))
      .build();

  }
}

C#

Befindet sich insrc/main/java/.../HelloCdkStack.java:


using Amazon.CDK;
using Constructs;
// Import the Lambda module
using Amazon.CDK.AWS.Lambda;

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define the Lambda function resource
      var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
      {
        Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
        Handler = "index.handler",
        Code = Code.FromInline(@"
          exports.handler = async function(event) {
            return {
              statusCode: 200,
              body: JSON.stringify('Hello World!'),
            };
          };
        "),
      });
    }
  }
}

Go

Befindet sich inhello-cdk.go:


package main

import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/constructs-go/constructs/v10"
  "github.com/aws/jsii-runtime-go"
  // Import the Lambda module
  "github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
)

type HelloCdkStackProps struct {
  awscdk.StackProps
}

func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
  var sprops awscdk.StackProps
  if props != nil {
    sprops = props.StackProps
  }
  stack := awscdk.NewStack(scope, &id, &sprops)

  // Define the Lambda function resource
  myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
    Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
    Handler: jsii.String("index.handler"),
    Code: awslambda.Code_FromInline(jsii.String(`
      exports.handler = async function(event) {
        return {
          statusCode: 200,
          body: JSON.stringify('Hello World!'),
        };
      };
    `)),
  })

  return stack
}

// ...

Schauen wir uns das Function Konstrukt genauer an. Wie alle Konstrukte benötigt die Function Klasse drei Parameter:

scope — Definiert Ihre Stack Instanz als übergeordnetes Objekt des Function Konstrukts. Alle Konstrukte, die AWS Ressourcen definieren, werden innerhalb des Gültigkeitsbereichs eines Stacks erstellt. Sie können Konstrukte innerhalb von Konstrukten definieren und so eine Hierarchie (Baum) erstellen. Hier und in den meisten Fällen ist this der Gültigkeitsbereich (in self Python).
Id — Die Konstrukt-ID von Function in Ihrer AWS CDK App. Diese ID sowie ein Hash, der auf der Position der Funktion innerhalb des Stacks basiert, identifizieren die Funktion während der Bereitstellung eindeutig. Sie verweist AWS CDK auch auf diese ID, wenn Sie das Konstrukt in Ihrer App aktualisieren und erneut bereitstellen, um die bereitgestellte Ressource zu aktualisieren. Hier lautet HelloWorldFunction Ihre Konstrukt-ID. Funktionen können auch einen Namen haben, der mit der functionName Eigenschaft angegeben wird. Dies unterscheidet sich von der Konstrukt-ID.
props — Ein Bündel von Werten, die Eigenschaften der Funktion definieren. Hier definieren Sie die code Eigenschaften runtimehandler, und.

Requisiten werden in den von der unterstützten Sprachen unterschiedlich dargestellt. AWS CDK
- In TypeScript and JavaScript, props ist ein einzelnes Argument und Sie übergeben ein Objekt, das die gewünschten Eigenschaften enthält.
- In Python, Requisiten werden als Schlüsselwortargumente übergeben.
- In Java, für die Übergabe der Requisiten steht ein Builder zur Verfügung. Es gibt zwei: einen für und einen zweitenFunctionProps, Function damit Sie das Konstrukt und das zugehörige Requisitenobjekt in einem Schritt erstellen können. Dieser Code verwendet Letzteres.
- In C#, instanziieren Sie ein FunctionProps Objekt mithilfe eines Objektinitialisierers und übergeben es als dritten Parameter.
Wenn die Requisiten eines Konstrukts optional sind, können Sie den Parameter komplett weglassen. props

Alle Konstrukte verwenden dieselben drei Argumente, sodass Sie beim Kennenlernen neuer Argumente leicht den Überblick behalten können. Und wie Sie vielleicht erwarten, können Sie jedes Konstrukt in Unterklassen unterteilen, um es an Ihre Bedürfnisse anzupassen oder wenn Sie die Standardwerte ändern möchten.

Schritt 7: Definieren Sie Ihre Lambda-Funktion URL

In diesem Schritt verwenden Sie die addFunctionUrl Hilfsmethode des Function Konstrukts, um eine Lambda-Funktion URL zu definieren. Um den Wert URL bei der Bereitstellung auszugeben, erstellen Sie mithilfe des CfnOutput Konstrukts eine AWS CloudFormation Ausgabe.

Fügen Sie Ihrer CDK Stack-Datei Folgendes hinzu:

TypeScript

Befindet sich inlib/hello-cdk-stack.ts:


// ...

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

    // Define the Lambda function resource
    // ...

    // Define the Lambda function URL resource
    const myFunctionUrl = myFunction.addFunctionUrl({
      authType: lambda.FunctionUrlAuthType.NONE,
    });

    // Define a CloudFormation output for your URL
    new cdk.CfnOutput(this, "myFunctionUrlOutput", {
      value: myFunctionUrl.url,
    })

  }
}

JavaScript

Befindet sich inlib/hello-cdk-stack.js:


const { Stack, CfnOutput } = require('aws-cdk-lib');  // Import CfnOutput

class HelloCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define the Lambda function resource
    // ...

    // Define the Lambda function URL resource
    const myFunctionUrl = myFunction.addFunctionUrl({
      authType: lambda.FunctionUrlAuthType.NONE,
    });

    // Define a CloudFormation output for your URL
    new CfnOutput(this, "myFunctionUrlOutput", {
      value: myFunctionUrl.url,
    })

  }
}

module.exports = { HelloCdkStack }

Python

Befindet sich inhello_cdk/hello_cdk_stack.py:


from aws_cdk import (
  # ...
  CfnOutput # Import CfnOutput
)
from constructs import Construct

class HelloCdkStack(Stack):

  def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
    super().__init__(scope, construct_id, **kwargs)

    # Define the Lambda function resource
    # ...

    # Define the Lambda function URL resource
    my_function_url = my_function.add_function_url(
      auth_type = _lambda.FunctionUrlAuthType.NONE,
    )

    # Define a CloudFormation output for your URL
    CfnOutput(self, "myFunctionUrlOutput", value=my_function_url.url)

Java

Befindet sich insrc/main/java/.../HelloCdkStack.java:


package com.myorg;

// ...
// Import Lambda function URL
import software.amazon.awscdk.services.lambda.FunctionUrl;
import software.amazon.awscdk.services.lambda.FunctionUrlAuthType;
import software.amazon.awscdk.services.lambda.FunctionUrlOptions;
// Import CfnOutput
import software.amazon.awscdk.CfnOutput;

public class HelloCdkStack extends Stack {
  public HelloCdkStack(final Construct scope, final String id) {
    this(scope, id, null);
  }

  public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
    super(scope, id, props);

    // Define the Lambda function resource
    // ...

    // Define the Lambda function URL resource
    FunctionUrl myFunctionUrl = myFunction.addFunctionUrl(FunctionUrlOptions.builder()
      .authType(FunctionUrlAuthType.NONE)
      .build());

    // Define a CloudFormation output for your URL
    CfnOutput.Builder.create(this, "myFunctionUrlOutput")
      .value(myFunctionUrl.getUrl())
      .build();
  }
}

C#

Befindet sich insrc/main/java/.../HelloCdkStack.java:


// ...

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define the Lambda function resource
      // ...

      // Define the Lambda function URL resource
      var myFunctionUrl = myFunction.AddFunctionUrl(new FunctionUrlOptions
      {
        AuthType = FunctionUrlAuthType.NONE
      });

      // Define a CloudFormation output for your URL
      new CfnOutput(this, "myFunctionUrlOutput", new CfnOutputProps
      {
        Value = myFunctionUrl.Url
      });
    }
  }
}

Go

Befindet sich inhello-cdk.go:


// ...

func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
  var sprops awscdk.StackProps
  if props != nil {
    sprops = props.StackProps
  }
  stack := awscdk.NewStack(scope, &id, &sprops)

  // Define the Lambda function resource
  // ...

  // Define the Lambda function URL resource
  myFunctionUrl := myFunction.AddFunctionUrl(&awslambda.FunctionUrlOptions{
    AuthType: awslambda.FunctionUrlAuthType_NONE,
  })

  // Define a CloudFormation output for your URL
  awscdk.NewCfnOutput(stack, jsii.String("myFunctionUrlOutput"), &awscdk.CfnOutputProps{
    Value: myFunctionUrl.Url(),
  })

  return stack
}

// ...

Warnung

Um dieses Tutorial einfach zu halten, URL ist Ihre Lambda-Funktion ohne Authentifizierung definiert. Bei der Bereitstellung wird dadurch ein öffentlich zugänglicher Endpunkt erstellt, der zum Aufrufen Ihrer Funktion verwendet werden kann. Wenn Sie mit diesem Tutorial fertig sind, folgen Sie Schritt 12: Löschen Sie Ihre Bewerbung den Anweisungen zum Löschen dieser Ressourcen.

Schritt 8: Synthetisieren Sie eine Vorlage CloudFormation

In diesem Schritt bereiten Sie sich auf die Bereitstellung vor, indem Sie eine CloudFormation Vorlage mit dem synthetisieren CDK CLI cdk synthBefehl. Dieser Befehl führt eine grundlegende Validierung Ihres CDK Codes durch, führt Ihre CDK App aus und generiert eine CloudFormation Vorlage aus Ihrem CDK Stack.

Wenn Ihre App mehr als einen Stapel enthält, müssen Sie angeben, welche Stapel synthetisiert werden sollen. Da Ihre App einen einzigen Stapel enthält, CDK CLI erkennt automatisch den zu synthetisierenden Stapel.

Wenn Sie kein Template synthetisieren, CDK CLI führt diesen Schritt bei der Bereitstellung automatisch aus. Wir empfehlen jedoch, diesen Schritt vor jeder Bereitstellung auszuführen, um nach Synthesefehlern zu suchen.

Bevor Sie eine Vorlage synthetisieren, können Sie optional Ihre Anwendung so erstellen, dass Syntax- und Typfehler erkannt werden. Detaillierte Anweisungen finden Sie unter Schritt 4: Erstellen Sie Ihre App CDK.

Um eine CloudFormation Vorlage zu synthetisieren, führen Sie den folgenden Befehl im Stammverzeichnis Ihres Projekts aus:


$ cdk synth

Anmerkung

Wenn Sie eine Fehlermeldung wie die folgende erhalten, überprüfen Sie, ob Sie sich im hello-cdk Verzeichnis befinden, und versuchen Sie es erneut:

--app is required either in command-line, in cdk.json or in ~/.cdk.json

Wenn dies erfolgreich ist, CDK CLI wird eine ausgeben YAML—formatierte CloudFormation Vorlage in stdout und speichert eine JSON—formatierte Vorlage im cdk.out Verzeichnis Ihres Projekts.

Im Folgenden finden Sie ein Beispiel für die Ausgabe der CloudFormation Vorlage:


Resources:
  HelloWorldFunctionServiceRoleunique-identifier:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Action: sts:AssumeRole
            Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
        Version: "2012-10-17"
      ManagedPolicyArns:
        - Fn::Join:
            - ""
            - - "arn:"
              - Ref: AWS::Partition
              - :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/ServiceRole/Resource
  HelloWorldFunctionunique-identifier:
    Type: AWS::Lambda::Function
    Properties:
      Code:
        ZipFile: "

          \        exports.handler = async function(event) {

          \          return {

          \            statusCode: 200,

          \            body: JSON.stringify('Hello World!'),

          \          };

          \        };

          \      "
      Handler: index.handler
      Role:
        Fn::GetAtt:
          - HelloWorldFunctionServiceRoleunique-identifier
          - Arn
      Runtime: nodejs20.x
    DependsOn:
      - HelloWorldFunctionServiceRoleunique-identifier
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
  HelloWorldFunctionFunctionUrlunique-identifier:
    Type: AWS::Lambda::Url
    Properties:
      AuthType: NONE
      TargetFunctionArn:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
  HelloWorldFunctioninvokefunctionurlunique-identifier:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunctionUrl
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
      FunctionUrlAuthType: NONE
      Principal: "*"
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
  CDKMetadata:
    Type: AWS::CDK::Metadata
    Properties:
      Analytics: v2:deflate64:unique-identifier
    Metadata:
      aws:cdk:path: HelloCdkStack/CDKMetadata/Default
    Condition: CDKMetadataAvailable
Outputs:
  myFunctionUrlOutput:
    Value:
      Fn::GetAtt:
        - HelloWorldFunctionFunctionUrlunique-identifier
        - FunctionUrl
Parameters:
  BootstrapVersion:
    Type: AWS::SSM::Parameter::Value<String>
    Default: /cdk-bootstrap/unique-identifier/version
    Description: Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]
Rules:
  CheckBootstrapVersion:
    Assertions:
      - Assert:
          Fn::Not:
            - Fn::Contains:
                - - "1"
                  - "2"
                  - "3"
                  - "4"
                  - "5"
                - Ref: BootstrapVersion
        AssertDescription: CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI.

Anmerkung

Jede generierte Vorlage enthält standardmäßig eine AWS::CDK::Metadata Ressource. Das AWS CDK Team verwendet diese Metadaten, um Einblicke in die AWS CDK Nutzung zu gewinnen und Möglichkeiten zu finden, diese zu verbessern. Einzelheiten, einschließlich der Deaktivierung der Versionsberichterstattung, finden Sie unterVersionsberichterstattung.

Durch die Definition eines einzigen L2-Konstrukts AWS CDK wird eine umfangreiche CloudFormation Vorlage erstellt, die Ihre Lambda-Ressourcen sowie die Berechtigungen und die Glue-Logik enthält, die für die Interaktion Ihrer Ressourcen in Ihrer Anwendung erforderlich sind.

Schritt 9: Stellen Sie Ihren Stack bereit CDK

In diesem Schritt verwenden Sie CDK CLI cdk deployBefehl zum Bereitstellen Ihres CDK Stacks. Dieser Befehl ruft Ihre generierte CloudFormation Vorlage ab und stellt sie bereit AWS CloudFormation, wodurch Ihre Ressourcen als Teil eines CloudFormation Stacks bereitgestellt werden.

Führen Sie im Stammverzeichnis Ihres Projekts den folgenden Befehl aus. Bestätigen Sie Änderungen, wenn Sie dazu aufgefordert werden:


$ cdk deploy

✨  Synthesis time: 2.69s

HelloCdkStack:  start: Building unique-identifier:current_account-current_region
HelloCdkStack:  success: Built unique-identifier:current_account-current_region
HelloCdkStack:  start: Publishing unique-identifier:current_account-current_region
HelloCdkStack:  success: Published unique-identifier:current_account-current_region
This deployment will make potentially sensitive changes according to your current security approval level (--require-approval broadening).
Please confirm you intend to make the following modifications:

IAM Statement Changes
┌───┬───────────────────────────────────────┬────────┬──────────────────────────┬──────────────────────────────┬───────────┐
│   │ Resource                              │ Effect │ Action                   │ Principal                    │ Condition │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction.Arn}             │ Allow  │ lambda:InvokeFunctionUrl │ *                            │           │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction/ServiceRole.Arn} │ Allow  │ sts:AssumeRole           │ Service:lambda.amazonaws.com │           │
└───┴───────────────────────────────────────┴────────┴──────────────────────────┴──────────────────────────────┴───────────┘
IAM Policy Changes
┌───┬───────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────┐
│   │ Resource                          │ Managed Policy ARN                                                             │
├───┼───────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────┤
│ + │ ${HelloWorldFunction/ServiceRole} │ arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole │
└───┴───────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────┘
(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)

Do you wish to deploy these changes (y/n)? y

Ähnlich wie müssen cdk synth Sie den AWS CDK Stack nicht angeben, da die App einen einzigen Stapel enthält.

Während der Bereitstellung CDK CLI zeigt Fortschrittsinformationen an, während Ihr Stack bereitgestellt wird. Wenn Sie fertig sind, können Sie zur AWS CloudFormation Konsole gehen, um Ihren HelloCdkStack Stack anzusehen. Sie können auch zur Lambda-Konsole gehen, um Ihre HelloWorldFunction Ressource anzuzeigen.

Wenn die Bereitstellung abgeschlossen ist, CDK CLI gibt Ihren Endpunkt ausURL. Kopieren Sie dies URL für den nächsten Schritt. Im Folgenden wird ein Beispiel gezeigt:


...
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...

 ✅  HelloCdkStack

✨  Deployment time: 41.65s

Outputs:
HelloCdkStack.myFunctionUrlOutput = https://<api-id>.lambda-url.<Region>.on.aws/
Stack ARN:
arn:aws:cloudformation:Region:account-id:stack/HelloCdkStack/unique-identifier

✨  Total time: 44.34s

Schritt 10: Interagieren Sie mit Ihrer Anwendung auf AWS

In diesem Schritt interagieren Sie mit Ihrer Anwendung, AWS indem Sie Ihre Lambda-Funktion über die Funktion aufrufen. URL Wenn Sie auf die zugreifenURL, gibt Ihre Lambda-Funktion die Hello World! Nachricht zurück.

Um Ihre Funktion aufzurufen, greifen Sie URL über Ihren Browser oder über die Befehlszeile auf die Funktion zu. Im Folgenden wird ein Beispiel gezeigt:


$ curl https://<api-id>.lambda-url.<Region>.on.aws/
"Hello World!"%

Schritt 11: Ändern Sie Ihre Anwendung

In diesem Schritt ändern Sie die Meldung, die die Lambda-Funktion zurückgibt, wenn sie aufgerufen wird. Sie führen einen Vergleich mit dem CDK CLI cdk diffBefehl, um eine Vorschau Ihrer Änderungen anzuzeigen und bereitzustellen, um Ihre Anwendung zu aktualisieren. Anschließend interagieren Sie mit Ihrer Anwendung AWS , um Ihre neue Nachricht zu sehen.

Ändern Sie die myFunction Instanz in Ihrer CDK Stack-Datei wie folgt:

TypeScript

Befindet sich inlib/hello-cdk-stack.ts:


// ...

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

    // Modify the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello CDK!'),
          };
        };
      `),
    });

    // ...

JavaScript

Befindet sich inlib/hello-cdk-stack.js:


// ...

class HelloCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Modify the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello CDK!'),
          };
        };
      `),
    });

    // ...

  }
}

module.exports = { HelloCdkStack }

Python

Befindet sich inhello_cdk/hello_cdk_stack.py:


# ...

class HelloCdkStack(Stack):

  def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
    super().__init__(scope, construct_id, **kwargs)

    # Modify the Lambda function resource
    my_function = _lambda.Function(
      self, "HelloWorldFunction", 
      runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
      handler = "index.handler",
      code = _lambda.Code.from_inline(
        """
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello CDK!'),
          };
        };
        """
      ),
    )

    # ...

Java

Befindet sich insrc/main/java/.../HelloCdkStack.java:


// ...

public class HelloCdkStack extends Stack {
  public HelloCdkStack(final Construct scope, final String id) {
    this(scope, id, null);
  }

  public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
    super(scope, id, props);

    // Modify the Lambda function resource
    Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
      .runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
      .handler("index.handler")
      .code(Code.fromInline(
        "exports.handler = async function(event) {" +
        " return {" +
        " statusCode: 200," +
        " body: JSON.stringify('Hello CDK!')" +
        " };" +
        "};"))
      .build();

    // ...
  }
}

C#


// ...

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Modify the Lambda function resource
      var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
      {
        Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
        Handler = "index.handler",
        Code = Code.FromInline(@"
          exports.handler = async function(event) {
            return {
              statusCode: 200,
              body: JSON.stringify('Hello CDK!'),
            };
          };
        "),
      });

      // ...
    }
  }
}

Go


// ...

type HelloCdkStackProps struct {
  awscdk.StackProps
}

func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
  var sprops awscdk.StackProps
  if props != nil {
    sprops = props.StackProps
  }
  stack := awscdk.NewStack(scope, &id, &sprops)

  // Modify the Lambda function resource
  myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
    Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
    Handler: jsii.String("index.handler"),
    Code: awslambda.Code_FromInline(jsii.String(`
      exports.handler = async function(event) {
        return {
          statusCode: 200,
          body: JSON.stringify('Hello CDK!'),
        };
      };
    `)),
  })

// ...

Derzeit wurden durch Ihre Codeänderungen keine direkten Aktualisierungen Ihrer bereitgestellten Lambda-Ressource vorgenommen. Ihr Code definiert den gewünschten Status Ihrer Ressource. Um Ihre bereitgestellte Ressource zu ändern, verwenden Sie CDK CLI um den gewünschten Status in einer neuen AWS CloudFormation Vorlage zu synthetisieren. Anschließend stellen Sie Ihre neue CloudFormation Vorlage als Änderungssatz bereit. Mit Änderungssätzen werden nur die Änderungen vorgenommen, die erforderlich sind, um den gewünschten neuen Status zu erreichen.

Führen Sie den cdk diff Befehl aus, um eine Vorschau Ihrer Änderungen anzuzeigen. Im Folgenden wird ein Beispiel gezeigt:


$ cdk diff
Stack HelloCdkStack
Hold on while we create a read-only change set to get a diff with accurate replacement information (use --no-change-set to use a less accurate but faster template-only diff)
Resources
[~] AWS::Lambda::Function HelloWorldFunction HelloWorldFunctionunique-identifier
 └─ [~] Code
     └─ [~] .ZipFile:
         ├─ [-] 
                exports.handler = async function(event) {
                    return {
                      statusCode: 200,
                      body: JSON.stringify('Hello World!'),
                    };
                };
                
         └─ [+] 
                exports.handler = async function(event) {
                    return {
                      statusCode: 200,
                      body: JSON.stringify('Hello CDK!'),
                    };
                };
                

✨  Number of stacks with differences: 1

Um diesen Diff zu erstellen, verwenden Sie CDK CLI fragt Ihr AWS-Konto Konto nach der neuesten AWS CloudFormation Vorlage für den HelloCdkStack Stack ab. Anschließend wird die neueste Vorlage mit der Vorlage verglichen, die sie gerade aus Ihrer App synthetisiert hat.

Führen Sie den cdk deploy Befehl aus, um Ihre Änderungen zu implementieren. Im Folgenden wird ein Beispiel gezeigt:


$ cdk deploy

✨  Synthesis time: 2.12s

HelloCdkStack:  start: Building unique-identifier:current_account-current_region
HelloCdkStack:  success: Built unique-identifier:current_account-current_region
HelloCdkStack:  start: Publishing unique-identifier:current_account-current_region
HelloCdkStack:  success: Published unique-identifier:current_account-current_region
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...

 ✅  HelloCdkStack

✨  Deployment time: 26.96s

Outputs:
HelloCdkStack.myFunctionUrlOutput = https://unique-identifier.lambda-url.<Region>.on.aws/
Stack ARN:
arn:aws:cloudformation:Region:account-id:stack/HelloCdkStack/unique-identifier

✨  Total time: 29.07s

Um mit Ihrer Anwendung zu interagieren, wiederholen Sie den VorgangSchritt 10: Interagieren Sie mit Ihrer Anwendung auf AWS. Im Folgenden wird ein Beispiel gezeigt:


$ curl https://<api-id>.lambda-url.<Region>.on.aws/
"Hello CDK!"%

Schritt 12: Löschen Sie Ihre Bewerbung

In diesem Schritt verwenden Sie CDK CLI cdk destroyBefehl zum Löschen Ihrer Anwendung. Dieser Befehl löscht den mit Ihrem CloudFormation Stack verknüpften CDK Stack, der die von Ihnen erstellten Ressourcen enthält.

Um Ihre Anwendung zu löschen, führen Sie den cdk destroy Befehl aus und bestätigen Sie Ihre Anfrage zum Löschen der Anwendung. Im Folgenden wird ein Beispiel gezeigt:


$ cdk destroy
Are you sure you want to delete: HelloCdkStack (y/n)? y
HelloCdkStack: destroying... [1/1]

 ✅  HelloCdkStack: destroyed

Nächste Schritte

Herzlichen Glückwunsch! Sie haben dieses Tutorial abgeschlossen und AWS CDK damit erfolgreich Ressourcen in der erstellt, geändert und gelöscht AWS Cloud. Sie sind jetzt bereit, mit der Verwendung von zu beginnen AWS CDK.

Weitere Informationen zur Verwendung von AWS CDK in Ihrer bevorzugten Programmiersprache finden Sie unterArbeite mit der AWS CDK Bibliothek.

Weitere Ressourcen finden Sie unter den folgenden Links:

Probieren Sie den CDKWorkshop aus, um sich eingehender mit einem komplexeren Projekt vertraut zu machen.
Sehen Sie sich die APIReferenz an, um mit der Erkundung der CDK Konstrukte zu beginnen, die für Ihre bevorzugten AWS Dienste verfügbar sind.
Besuchen Sie Construct Hub, um Konstrukte zu entdecken, die von AWS und anderen erstellt wurden.
Entdecken Sie Beispiele für die AWS CDK Verwendung von.

Das AWS CDK ist ein Open-Source-Projekt. Informationen zum Beitrag finden Sie unter Beitrag zum AWS Cloud Development Kit (AWS CDK).

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Erste Schritte

Arbeite mit der CDK Bibliothek

Tutorial: Erstelle deine erste AWS CDK App

Voraussetzungen

Über dieses Tutorial

Schritt 1: Erstellen Sie Ihr CDK Projekt

Um ein CDK Projekt zu erstellen

Wichtig

Schritt 2: Konfigurieren Sie Ihre AWS Umgebung

Um das zu verwenden AWS CLI , um Ihre AWS-Konto ID zu erhalten

Um das AWS CLI zu verwenden, um Ihr AWS-Region

So konfigurieren Sie die Umgebung für Ihren CDK Stack

Schritt 3: Bootstrap für Ihre Umgebung AWS

Schritt 4: Erstellen Sie Ihre App CDK

Schritt 5: Listet die CDK Stapel in eurer App auf

Schritt 6: Definieren Sie Ihre Lambda-Funktion

Schritt 7: Definieren Sie Ihre Lambda-Funktion URL

Warnung

Schritt 8: Synthetisieren Sie eine Vorlage CloudFormation

Anmerkung

Anmerkung

Schritt 9: Stellen Sie Ihren Stack bereit CDK

Schritt 10: Interagieren Sie mit Ihrer Anwendung auf AWS

Schritt 11: Ändern Sie Ihre Anwendung

Schritt 12: Löschen Sie Ihre Bewerbung

Nächste Schritte