Pré-requisitos Sobre este tutorial Etapa 1: criar seu projeto do CDK Etapa 2: configurar seu ambiente AWS Etapa 3: inicialize seu ambiente AWS Etapa 4: compilar sua aplicação do CDK Etapa 5: listar as pilhas do CDK em sua aplicação Etapa 6: definir sua função do Lambda Etapa 7: Definir seu URL da função do Lambda Etapa 8: Sintetizar um modelo do CloudFormation Etapa 9: Implantar sua pilha do CDK Etapa 10: Interaja com sua aplicação no AWS Etapa 11: Modificar sua aplicação Etapa 12: Excluir sua aplicação Próximas etapas

Tutorial: criação da sua primeira aplicação do AWS CDK

Comece a usar o kit de desenvolvimento em nuvem da AWS (CDK da AWS) a partir da interface de linha de comandos do CDK AWS (CLI do CDK da AWS) para desenvolver sua primeira aplicação do CDK, fazer o bootstrapping do seu ambiente da AWS e implantar sua aplicação no AWS.

Pré-requisitos

Antes de iniciar este tutorial, conclua todas as etapas de configuração em Conceitos básicos do AWS CDK.

Sobre este tutorial

Neste tutorial, você criará e implantará uma aplicação simples no AWS usando o AWS CDK. A aplicação consiste em uma função do AWS Lambda que retorna uma mensagem Hello World! quando invocada. A função será invocada por meio de um URL de função do Lambda que serve como um endpoint HTTP(S) dedicado para sua função do Lambda.

Usando este tutorial, você fará o seguinte:

Crie seu projeto: crie um projeto do CDK usando o comando cdk init da CLI do CDK.
Configure seu ambiente AWS – Configure o ambiente AWS no qual você implantará sua aplicação.
Inicialize seu ambiente da AWS: prepare seu ambiente da AWS para implantação fazendo o bootstrapping com o comando cdk bootstrap da CLI do CDK.
Desenvolva sua aplicação – Use constructos da Biblioteca de Constructos da AWS para definir sua função do Lambda e os recursos de URL da função do Lambda.
Prepare sua aplicação para implantação: use a CLI do CDK para criar sua aplicação e sintetizar um modelo do AWS CloudFormation.
Implante sua aplicação: use o comando cdk deploy da CLI do CDK para implantar sua aplicação e provisionar seus recursos da AWS.
Interaja com sua aplicação — Interaja com sua função do Lambda implantada no AWS invocando-a e recebendo uma resposta.
Modifique sua aplicação — Modifique sua função do Lambda e implante para implementar suas alterações.
Exclua sua aplicação: exclua todos os recursos que você criou usando o comando cdk destroy da CLI do CDK.

Etapa 1: criar seu projeto do CDK

Nesta etapa, você cria um novo projeto do CDK. Um projeto do CDK deve estar em seu próprio diretório, com suas próprias dependências de módulos locais.

Para criar um projeto do CDK

Em um diretório inicial de sua escolha, crie e navegue até um diretório chamado hello-cdk:
```
$ mkdir hello-cdk && cd hello-cdk
```
Importante
Certifique-se de nomear o diretório do seu projeto hello-cdk, exatamente como mostrado aqui. A CLI do CDK usa esse nome de diretório para nomear coisas dentro do seu código do CDK. Se você escolher outro nome de diretório, você terá problemas durante este tutorial.
A partir do diretório hello-cdk, inicialize um novo projeto do CDK usando o comando cdk init da CLI do CDK. Especifique o modelo app e sua linguagem de programação preferida com a opção --language:
TypeScript

$ cdk init app --language typescript

JavaScript

$ cdk init app --language javascript

Python

$ cdk init app --language python

Depois que a aplicação for criado, insira também os dois comandos a seguir. Eles ativam o ambiente virtual Python da aplicação e instalam as dependências principais do AWS CDK.

$ source .venv/bin/activate # On Windows, run `.\venv\Scripts\activate` instead $ python -m pip install -r requirements.txt

Java

$ cdk init app --language java

Se você estiver usando um IDE, agora você pode abrir ou importar o projeto. No Eclipse, por exemplo, escolha Arquivo > Importar > Maven > Projetos existentes do Maven. Certifique-se de que as configurações do projeto estejam definidas para usar o Java 8 (1.8).

C#

$ cdk init app --language csharp

Se você estiver usando o Visual Studio, abra o arquivo da solução no diretório src.

Go

$ cdk init app --language go

Depois que a aplicação for criado, insira também o comando a seguir para instalar os módulos da Biblioteca de Constructos da AWS que a aplicação exige.

$ go get

O comando cdk init cria uma estrutura de arquivos e pastas dentro do diretório hello-cdk para ajudar a organizar o código-fonte da sua aplicação CDK. Essa estrutura de arquivos e pastas é chamada de projeto do CDK. Reserve um momento para explorar seu projeto do CDK.

Se você instalou o Git, cada projeto que você cria usando também cdk init é inicializado como um repositório Git.

Durante a inicialização do projeto, a CLI do CDK cria uma aplicação do CDK contendo uma única pilha do CDK. A instância da aplicação do CDK é criada usando o constructo App. A seguir está uma parte desse código do seu arquivo de aplicação CDK:

TypeScript

Localizado em bin/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

Localizado em bin/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

Localizado em app.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

Localizado em src/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#

Localizado em src/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

Localizado em hello-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)
}

// ...

A pilha do CDK é criada usando o constructo Stack. A seguir está uma parte desse código do seu arquivo de pilha CDK:

TypeScript

Localizado em lib/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

Localizado em lib/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

Localizado em hello_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

Localizado em src/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#

Localizado em src/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

Localizado em hello-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
}

// ...

Etapa 2: configurar seu ambiente AWS

Nesta etapa, você configura o ambiente AWS para sua pilha do CDK. Ao fazer isso, você especifica em qual ambiente sua pilha do CDK será implantada.

Primeiro, determine o ambiente AWS que você deseja usar. Um ambiente da AWS consiste em uma conta da AWS e uma região da AWS.

Ao usar a AWS CLI para configurar as credenciais de segurança em sua máquina local, é possível então usar a AWS CLI para obter informações de ambiente da AWS para um perfil específico.

Para usar a AWS CLI para obter seu ID de conta da AWS

Execute o comando da AWS CLI a seguir para obter o ID da conta da AWS para seu perfil default:
```
$ aws sts get-caller-identity --query "Account" --output text
```
Se você preferir usar um perfil nomeado, forneça o nome do seu perfil usando a opção --profile:
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```

Para usar a AWS CLI para obter sua região da AWS

Execute o comando da AWS CLI a seguir para obter a região que você configurou para seu perfil default:
```
$ aws configure get region
```
Se você preferir usar um perfil nomeado, forneça o nome do seu perfil usando a opção --profile:
```
$ aws configure get region --profile your-profile-name
```

Em seguida, você configurará o ambiente AWS para sua pilha do CDK modificando a instância HelloCdkStack no arquivo da aplicação. Neste tutorial, você codificará as informações do seu ambiente AWS. Isso é recomendado para ambientes de produção. Para obter informações sobre outras formas de configurar ambientes, consulte Configuração de ambientes para uso com o AWS CDK.

Configurar o ambiente para sua pilha do CDK

No seu arquivo da aplicação, use a propriedade env do constructo Stack para configurar seu ambiente. Veja um exemplo a seguir:

TypeScript

Localizado em bin/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

Localizado em bin/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

Localizado em app.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

Localizado em src/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#

Localizado em src/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

Localizado em hello-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"),
	}
}

Etapa 3: inicialize seu ambiente AWS

Nesta etapa, você inicializa o ambiente AWS que configurou na etapa anterior. Isso prepara seu ambiente para implantações do CDK.

Para inicializar seu ambiente, execute o seguinte a partir da raiz do seu projeto do CDK:


$ cdk bootstrap

Ao fazer o bootstrapping a partir da raiz do seu projeto do CDK, você não precisa fornecer nenhuma informação adicional. A CLI do CDK obtém informações sobre o ambiente do seu projeto. Ao fazer o bootstrapping fora de um projeto do CDK, é necessário fornecer informações do ambiente com o comando cdk bootstrap. Para obter mais informações, consulte Bootstrapping do seu ambiente para uso com o AWS CDK.

Etapa 4: compilar sua aplicação do CDK

Na maioria dos ambientes de programação, você cria ou compila o código depois de fazer alterações. Isso não é necessário com o AWS CDK, pois a CLI do CDK executará essa etapa automaticamente. No entanto, você ainda pode criar manualmente quando quiser detectar erros de sintaxe e tipo. Veja um exemplo a seguir:

Etapa 5: listar as pilhas do CDK em sua aplicação

Neste momento, é preciso ter uma aplicação CDK contendo uma única pilha do CDK. Para verificar, use o comando cdk list da CLI do CDK para exibir suas pilhas. A saída deve exibir uma única pilha chamada HelloCdkStack:


$ cdk list
HelloCdkStack

Se não vir essa saída, verifique se você está no diretório de trabalho correto do projeto e tente novamente. Se você ainda não vir sua pilha, repita a Etapa 1: criação do seu projeto do CDK e tente novamente.

Etapa 6: definir sua função do Lambda

Nesta etapa, você importa o módulo aws_lambda da Biblioteca de Constructos da AWS e usa o constructo L2 Function.

Modifique seu arquivo de pilha CDK da seguinte forma:

TypeScript

Localizado em lib/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

Localizado em lib/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

Localizado em hello_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

Localizado em src/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#

Localizado em src/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

Localizado em hello-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
}

// ...

Vamos analisar o constructo Function mais de perto. Como todos os constructos, a classe Function usa três parâmetros:

escopo — Define sua instância Stack como pai do constructo Function. Todos os constructos que definem recursos AWS são criados dentro do escopo de uma pilha. É possível definir constructos dentro de constructos, criando uma hierarquia (árvore). Aqui, e na maioria dos casos, o escopo é this (self em Python).
Id: o ID de constructo da Function dentro da sua aplicação do AWS. Esse ID, mais um hash baseado na localização da função na pilha, identifica exclusivamente a função durante a implantação. O AWS CDK também faz referência a esse ID quando você atualiza o constructo em sua aplicação e reimplanta para atualizar o recurso implantado. Aqui, seu ID de constructo é HelloWorldFunction. As funções também podem ter um nome, especificado com a propriedade functionName. Isto é diferente do ID do constructo.
props — Um pacote de valores que define as propriedades da função. Aqui você define as propriedades runtime, handler e code.

Os props são representados de forma diferente nas linguagens com suporte no AWS CDK.
- No TypeScript e no JavaScript, props é um único argumento e você passa um objeto contendo as propriedades desejadas.
- No Python, os props são passados como argumentos de palavras-chave.
- No Java, um Construtor é fornecido para passar os props. Existem dois: um para o FunctionProps e um segundo para o Function para permitir que você construa o constructo e seu objeto de props em uma única etapa. Esse código usa o último.
- Em C#, você instancia um objeto FunctionProps usando um inicializador de objetos e o passa como terceiro parâmetro.
  
  Se os props de um constructo forem opcionais, será possível omitir totalmente o parâmetro props.

Todos os constructos usam esses mesmos três argumentos, então é fácil se manter orientado à medida que você aprende sobre argumentos novos. E, como era de se esperar, você pode subclassificar qualquer constructo para estendê-lo de acordo com suas necessidades ou se quiser alterar seus padrões.

Etapa 7: Definir seu URL da função do Lambda

Nesta etapa, você usa o método auxiliar addFunctionUrl do constructo Function para definir o URL de uma função do Lambda. Para gerar o valor desse URL na implantação, você criará uma saída de AWS CloudFormation usando o constructo CfnOutput.

Adicione o seguinte ao seu arquivo de pilha CDK:

TypeScript

Localizado em lib/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

Localizado em lib/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

Localizado em hello_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

Localizado em src/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#

Localizado em src/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

Localizado em hello-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
}

// ...

Atenção

Para manter esse tutorial simples, o URL da função do Lambda é definido sem autenticação. Quando implantado, isso cria um endpoint acessível ao público que pode ser usado para invocar sua função. Ao concluir este tutorial, siga a Etapa 12: exclusão da sua aplicação para excluir esses recursos.

Etapa 8: Sintetizar um modelo do CloudFormation

Nesta etapa, você se prepara para a implantação sintetizando um modelo do CloudFormation com o comando cdk synth da CLI do CDK. Esse comando executa a validação básica do seu código do CDK, executa sua aplicação do CDK e gera um modelo do CloudFormation a partir de sua pilha do CDK.

Se sua aplicação contiver mais de uma pilha, você deverá especificar quais pilhas sintetizar. Como sua aplicação contém uma única pilha, a CLI do CDK detecta automaticamente a pilha a sintetizar.

Se você não sintetizar um modelo, a CLI do CDK executará automaticamente essa etapa quando você implantar. No entanto, recomendamos executar essa etapa antes de cada implantação para verificar se há erros de síntese.

Antes de sintetizar um modelo, você pode, opcionalmente, criar sua aplicação para capturar erros de sintaxe e de tipo. Para obter instruções, consulte Etapa 4: compilação da sua aplicação do CDK.

Para sintetizar um modelo do CloudFormation, execute o seguinte a partir da raiz do seu projeto:


$ cdk synth

nota

Se você receber um erro como o seguinte, verifique se você está no diretório hello-cdk e tente novamente:

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

Se tiver êxito, a CLI do CDK exibirá um modelo do CloudFormation formatado em YAML para stdout e salvará um modelo formatado em JSON no diretório cdk.out do seu projeto.

Veja a seguir um exemplo de saída do modelo do CloudFormation:


Resources:
  HelloWorldFunctionServiceRole<unique-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
  HelloWorldFunction<unique-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:
          - HelloWorldFunctionServiceRole<unique-identifier>
          - Arn
      Runtime: nodejs20.x
    DependsOn:
      - HelloWorldFunctionServiceRole<unique-identifier>
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
  HelloWorldFunctionFunctionUrl<unique-identifier>:
    Type: AWS::Lambda::Url
    Properties:
      AuthType: NONE
      TargetFunctionArn:
        Fn::GetAtt:
          - HelloWorldFunction<unique-identifier>
          - Arn
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
  HelloWorldFunctioninvokefunctionurl<unique-identifier>:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunctionUrl
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunction<unique-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:
        - HelloWorldFunctionFunctionUrl<unique-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.

nota

Cada modelo gerado contém um recurso AWS::CDK::Metadata por padrão. A equipe do AWS CDK usa esses metadados para obter informações sobre o uso do AWS CDK e para encontrar maneiras de melhorá-lo. Para obter detalhes, incluindo como optar por não receber relatórios de versão, consulte Relatórios de versão.

Ao definir um único constructo L2, o CDK da AWS cria um modelo abrangente do CloudFormation contendo seus recursos do Lambda, junto com as permissões e a lógica de colagem necessárias para que seus recursos interajam com sua aplicação.

Etapa 9: Implantar sua pilha do CDK

Nesta etapa, você usa o comando cdk deploy da CLI do CDK para implantar sua pilha do CDK. Esse comando recupera seu modelo gerado do CloudFormation e o implanta por meio do AWS, CloudFormation, que provisiona seus recursos como parte de uma pilha do CloudFormation.

Da raiz do seu projeto, execute o seguinte. Confirme as alterações, se solicitado:


$ 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

Da mesma forma que com cdk synth, você não precisa especificar a pilha do AWS CDK, pois a aplicação contém uma única pilha.

Durante a implantação, a CLI do CDK exibirá informações de andamento à medida que sua pilha é implantada. Quando terminar, será possível acessar o console do AWS CloudFormation para ver sua pilha HelloCdkStack. Você também pode acessar o console Lambda para ver seu recurso HelloWorldFunction.

Quando a implantação for concluída, a CLI do CDK exibirá o URL do seu endpoint. Copie esse URL para a próxima etapa. Veja um exemplo a seguir:


...
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

Etapa 10: Interaja com sua aplicação no AWS

Nesta etapa, você interage com sua aplicação no AWS invocanda sua função do Lambda por meio do URL da função. Quando você acessa o URL, sua função do Lambda retorna a mensagem Hello World!.

Para invocar sua função, acesse o URL da função pelo navegador ou pela linha de comando. Veja um exemplo a seguir:


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

Etapa 11: Modificar sua aplicação

Nesta etapa, você modifica a mensagem que a função do Lambda retorna quando invocada. Você executa uma comparação usando o comando cdk diff da CLI do CDK para visualizar suas alterações e implantar para atualizar sua aplicação. Em seguida, você interage com sua aplicação no AWS para ver sua nova mensagem.

Modifique a instância myFunction em seu arquivo de pilha CDK da seguinte forma:

TypeScript

Localizado em lib/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

Localizado em lib/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

Localizado em hello_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

Localizado em src/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!'),
        };
      };
    `)),
  })

// ...

}

Atualmente, suas alterações de código não fizeram nenhuma atualização direta em seu recurso Lambda implantado. Seu código define o estado desejado do seu recurso. Para modificar seu recurso implantado, você usará a CLI do CDK para sintetizar o estado desejado em um novo modelo do AWS CloudFormation. Em seguida, você implantará seu novo modelo do CloudFormation como um conjunto de alterações. Os conjuntos de alterações fazem somente as alterações necessárias para alcançar o novo estado desejado.

Para visualizar suas alterações, execute o comando cdk diff. Veja um exemplo a seguir:


$ 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 HelloWorldFunction<unique-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

Para criar essa diferença, o a CLI do CDK consulta sua conta da AWS para obter o modelo do AWS CloudFormation mais recente para a pilha HelloCdkStack. Em seguida, ele compara o modelo mais recente com o modelo que acabou de sintetizar da sua aplicação.

Para implementar suas alterações, execute o comando cdk deploy. Veja um exemplo a seguir:


$ 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

Para interagir com sua aplicação, repita a Etapa 10: interação com sua aplicação na AWS. Veja um exemplo a seguir:


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

Etapa 12: Excluir sua aplicação

Nesta etapa, você usa o comando cdk destroy da CLI do CDK para excluir sua aplicação. Esse comando exclui a pilha do CloudFormation associada à sua pilha CDK, que inclui os recursos que você criou.

Para excluir sua aplicação, execute o comando cdk destroy e confirme sua solicitação para excluir a aplicação. Veja um exemplo a seguir:


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

 ✅  HelloCdkStack: destroyed

Próximas etapas

Parabéns! Você concluiu este tutorial e usou o AWS CDK com sucesso para criar, modificar e excluir recursos na Nuvem AWS. Agora está tudo pronto para começar a usar o AWS CDK.

Para saber mais sobre como usar o AWS CDK em sua linguagem de programação preferida, consulte Trabalho dom a Biblioteca do AWS CDK.

Para recursos adicionais, consulte o seguinte:

Experimente o CDK Workshop para um tour mais aprofundado envolvendo um projeto mais complexo.
Consulte a referência de API para começar a explorar os constructos do CDK disponíveis para seus serviços da AWS favoritos.
Visite o Hub de Constructos para descobrir constructos criados pelo AWS e outros.
Explore exemplos de uso do AWS CDK.

O AWS CDK é um projeto de código-fonte aberto. Para contribuir, consulte Contribuição ao kit de desenvolvimento em nuvem da AWS (CDK da AWS).

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Começar

Trabalhe com a biblioteca CDK

Tutorial: criação da sua primeira aplicação do AWS CDK

Pré-requisitos

Sobre este tutorial

Etapa 1: criar seu projeto do CDK

Importante

Etapa 2: configurar seu ambiente AWS

Etapa 3: inicialize seu ambiente AWS

Etapa 4: compilar sua aplicação do CDK

Etapa 5: listar as pilhas do CDK em sua aplicação

Etapa 6: definir sua função do Lambda

Etapa 7: Definir seu URL da função do Lambda

Atenção

Etapa 8: Sintetizar um modelo do CloudFormation

nota

nota

Etapa 9: Implantar sua pilha do CDK

Etapa 10: Interaja com sua aplicação no AWS

Etapa 11: Modificar sua aplicação

Etapa 12: Excluir sua aplicação

Próximas etapas