As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Passo a passo - Parte 1
**nota**
Os constructos de soluções da AWS são compatíveis com as versões CDK da AWS ≥ 1.46.0.
Este tutorial mostra como criar e implantar um aplicativo simples “Hello Constructs” da AWS CDK que usa um padrão do AWS Solutions Constructs, desde a inicialização do projeto até a implantação do modelo resultante do AWS CloudFormation. O aplicativo Hello Constructs criará a seguinte solução simples:
## Hello constructos
Vamos começar a criar nosso primeiro aplicativo AWS CDK usando desenvolvimento baseado em padrões.
**nota**
Esta é uma modificação de exemplo do`Hello CDK!`do[Workshop CDK](https://cdkworkshop.com/). Se esta é a primeira vez que você usa o AWS CDK, recomendamos começar com este workshop para um passo a passo prático e como aproveitar o CDK na criação de um projeto do mundo real.
## Criando o diretório de aplicativos e inicializando o CDK da AWS
Crie um diretório para seu aplicativo CDK e, em seguida, crie um aplicativo AWS CDK nesse diretório.
------
#### [ TypeScript ]
```
mkdir hello-constructs
cd hello-constructs
cdk init --language typescript
```
------
#### [ Python ]
```
mkdir hello-constructs
cd hello-constructs
cdk init --language python
```
------
**dica**
Agora é um bom momento para abrir o projeto no seu IDE favorito e explorar. Para saber mais sobre a estrutura do projeto, selecione o link apropriado:
[TypeScript](https://cdkworkshop.com/20-typescript/20-create-project/300-structure.html)
[Python](https://cdkworkshop.com/30-python/20-create-project/300-structure.html)
## Atualizar dependências da base do projeto
**Atenção**
Para garantir a funcionalidade adequada, os AWS Solutions Constructs e os pacotes de CDK da AWS devem usar o mesmo número de versão em seu projeto. Por exemplo, se você estiver usando AWS Solutions Constructs v.1.52.0, você também deve usar o AWS CDK v.1.52.0.
**dica**
Anote a versão mais recente do AWS Solutions Constructs e aplique esse número de versão ao`VERSION_NUMBER`espaços reservados nas etapas abaixo (para construções de soluções da AWS e pacotes CDK da AWS). Para verificar todas as versões públicas da biblioteca de Construtos,[Clique aqui](https://github.com/awslabs/aws-solutions-constructs/releases).
------
#### [ TypeScript ]
Edite a`package.json`com as seguintes informações:
```
"devDependencies": {
"@aws-cdk/assert": "VERSION_NUMBER",
"@types/jest": "^24.0.22",
"@types/node": "10.17.5",
"jest": "^24.9.0",
"ts-jest": "^24.1.0",
"aws-cdk": "VERSION_NUMBER",
"ts-node": "^8.1.0",
"typescript": "~3.7.2"
},
"dependencies": {
"@aws-cdk/core": "VERSION_NUMBER",
"source-map-support": "^0.5.16"
}
```
------
#### [ Python ]
Edite a`setup.py`com as seguintes informações:
```
install_requires=[
"aws-cdk.core==VERSION_NUMBER",
],
```
------
Instale as dependências de base de projetos.
------
#### [ TypeScript ]
```
npm install
```
------
#### [ Python ]
```
source .venv/bin/activate
pip install -r requirements.txt
```
------
Crie e execute o aplicativo e confirme se ele cria uma pilha vazia.
------
#### [ TypeScript ]
```
npm run build
cdk synth
```
------
#### [ Python ]
```
cdk synth
```
------
Você deve ver uma pilha como a seguinte, em que`CDK-VERSION`é a versão do CDK. (Sua saída pode diferir ligeiramente do que é mostrado aqui.)
------
#### [ TypeScript ]
```
Resources:
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Modules: aws-cdk=CDK-VERSION,@aws-cdk/core=VERSION_NUMBER,@aws-cdk/cx-api=VERSION_NUMBER,jsii-runtime=node.js/10.17.0
```
------
#### [ Python ]
```
Resources:
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Modules: aws-cdk=CDK-VERSION,@aws-cdk/core=VERSION_NUMBER,@aws-cdk/cx-api=VERSION_NUMBER,jsii-runtime=Python/3.7.7
```
------
## Código de manipulador do Lambda
Vamos começar com o código de manipulador do AWS Lambda.
Criar um diretório do`lambda`na raiz da árvore de seu projeto.
------
#### [ TypeScript ]
Adicionar um arquivo chamado`lambda/hello.js`com o seguinte conteúdo:
```
exports.handler = async function(event) {
console.log("request:", JSON.stringify(event, null, 2));
return {
statusCode: 200,
headers: { "Content-Type": "text/plain" },
body: `Hello, AWS Solutions Constructs! You've hit ${event.path}\n`
};
};
```
------
#### [ Python ]
Adicionar um arquivo chamado`lambda/hello.py`com o seguinte conteúdo:
```
import json
def handler(event, context):
print('request: {}'.format(json.dumps(event)))
return {
'statusCode': 200,
'headers': {
'Content-Type': 'text/plain'
},
'body': 'Hello, CDK! You have hit {}\n'.format(event['path'])
}
```
------
Esta é uma função simples do Lambda que retorna o texto “Olá, Constructs\! Você apertou [url path]”. A saída da função também inclui o código de status HTTP e cabeçalhos HTTP. Eles são usados pelo API Gateway para formular a resposta HTTP para o usuário.
Este Lambda é fornecido em JavaScript. Para obter mais informações sobre como escrever funções do Lambda em seu idioma de escolha, consulte o[Documentação do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).
## Instale as dependências do AWS CDK e do AWS Solutions Constructs
O AWS Solutions Constructs é fornecido com uma extensa biblioteca de construções. A biblioteca é dividida em módulos, um para cada padrão bem arquitetado. Por exemplo, se você quiser definir uma API do Amazon API Gateway Rest para uma função do AWS Lambda, precisaremos usar o`aws-apigateway-lambda`Biblioteca de padrões.
Também precisamos adicionar a biblioteca de construções do AWS Lambda e do Amazon API Gateway a partir do AWS CDK.
Instale o módulo do AWS Lambda e todas as suas dependências em nosso projeto:
**nota**
Lembre-se de substituir a versão correta e correspondente a ser usada para construções de soluções da AWS e para o CDK da AWS no`VERSION_NUMBER`campos de espaço reservado para cada comando. Versões incompatíveis entre pacotes podem causar erros.
------
#### [ TypeScript ]
```
npm install -s @aws-cdk/aws-lambda@VERSION_NUMBER
```
------
#### [ Python ]
```
pip install aws_cdk.aws_lambda==VERSION_NUMBER
```
------
Em seguida, instale o módulo Amazon API Gateway e todas as suas dependências em nosso projeto:
------
#### [ TypeScript ]
```
npm install -s @aws-cdk/aws-apigateway@VERSION_NUMBER
```
------
#### [ Python ]
```
pip install aws_cdk.aws_apigateway==VERSION_NUMBER
```
------
Por fim, instale os Construtos de soluções da AWS`aws-apigateway-lambda`e todas as suas dependências em nosso projeto:
------
#### [ TypeScript ]
```
npm install -s @aws-solutions-constructs/aws-apigateway-lambda@VERSION_NUMBER
```
------
#### [ Python ]
```
pip install aws_solutions_constructs.aws_apigateway_lambda==VERSION_NUMBER
```
------
## Adicione um padrão do Amazon API Gateway/AWS Lambda à sua pilha
Agora, vamos definir o padrão AWS Solutions Constructs para implementar um Amazon API Gateway com um proxy AWS Lambda.
------
#### [ TypeScript ]
Editar o arquivo`lib/hello-constructs.ts`com o seguinte:
```
import * as cdk from '@aws-cdk/core';
import * as lambda from '@aws-cdk/aws-lambda';
import * as api from '@aws-cdk/aws-apigateway';
import { ApiGatewayToLambda, ApiGatewayToLambdaProps } from '@aws-solutions-constructs/aws-apigateway-lambda';
export class HelloConstructsStack extends cdk.Stack {
constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// The code that defines your stack goes here
const api_lambda_props: ApiGatewayToLambdaProps = {
lambdaFunctionProps: {
code: lambda.Code.fromAsset('lambda'),
runtime: lambda.Runtime.NODEJS_12_X,
handler: 'hello.handler'
},
apiGatewayProps: {
defaultMethodOptions: {
authorizationType: api.AuthorizationType.NONE
}
}
};
new ApiGatewayToLambda(this, 'ApiGatewayToLambda', api_lambda_props);
}
}
```
------
#### [ Python ]
Editar o arquivo`hello_constructs/hello_constructs_stack.py`com o seguinte:
```
from aws_cdk import (
aws_lambda as _lambda,
aws_apigateway as apigw,
core,
)
from aws_solutions_constructs import (
aws_apigateway_lambda as apigw_lambda
)
class HelloConstructsStack(core.Stack):
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
# The code that defines your stack goes here
apigw_lambda.ApiGatewayToLambda(
self, 'ApiGatewayToLambda',
lambda_function_props=_lambda.FunctionProps(
runtime=_lambda.Runtime.PYTHON_3_7,
code=_lambda.Code.asset('lambda'),
handler='hello.handler',
),
api_gateway_props=apigw.RestApiProps(
default_method_options=apigw.MethodOptions(
authorization_type=apigw.AuthorizationType.NONE
)
)
)
```
------
É isso. Isso é tudo o que você precisa fazer para definir um API Gateway que proxies todas as solicitações para uma função do AWS Lambda. Vamos comparar nossa nova pilha com a original:
------
#### [ TypeScript ]
```
npm run build
cdk diff
```
------
#### [ Python ]
```
cdk diff
```
------
O resultado deve ser semelhante ao seguinte:
```
Stack HelloConstructsStack
IAM Statement Changes
┌───┬─────────────────────────────┬────────┬─────────────────────────────┬─────────────────────────────┬──────────────────────────────┐
│ │ Resource │ Effect │ Action │ Principal │ Condition │
├───┼─────────────────────────────┼────────┼─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤
│ + │ ${LambdaFunction.Arn} │ Allow │ lambda:InvokeFunction │ Service:apigateway.amazonaw │ "ArnLike": { │
│ │ │ │ │ s.com │ "AWS:SourceArn": "arn:${AW │
│ │ │ │ │ │ S::Partition}:execute-api:${ │
│ │ │ │ │ │ AWS::Region}:${AWS::AccountI │
│ │ │ │ │ │ d}:${RestApi0C43BF4B}/${Rest │
│ │ │ │ │ │ Api/DeploymentStage.prod}/*/ │
│ │ │ │ │ │ {proxy+}" │
│ │ │ │ │ │ } │
│ + │ ${LambdaFunction.Arn} │ Allow │ lambda:InvokeFunction │ Service:apigateway.amazonaw │ "ArnLike": { │
│ │ │ │ │ s.com │ "AWS:SourceArn": "arn:${AW │
│ │ │ │ │ │ S::Partition}:execute-api:${ │
│ │ │ │ │ │ AWS::Region}:${AWS::AccountI │
│ │ │ │ │ │ d}:${RestApi0C43BF4B}/test-i │
│ │ │ │ │ │ nvoke-stage/*/{proxy+}" │
│ │ │ │ │ │ } │
│ + │ ${LambdaFunction.Arn} │ Allow │ lambda:InvokeFunction │ Service:apigateway.amazonaw │ "ArnLike": { │
│ │ │ │ │ s.com │ "AWS:SourceArn": "arn:${AW │
│ │ │ │ │ │ S::Partition}:execute-api:${ │
│ │ │ │ │ │ AWS::Region}:${AWS::AccountI │
│ │ │ │ │ │ d}:${RestApi0C43BF4B}/${Rest │
│ │ │ │ │ │ Api/DeploymentStage.prod}/*/ │
│ │ │ │ │ │ " │
│ │ │ │ │ │ } │
│ + │ ${LambdaFunction.Arn} │ Allow │ lambda:InvokeFunction │ Service:apigateway.amazonaw │ "ArnLike": { │
│ │ │ │ │ s.com │ "AWS:SourceArn": "arn:${AW │
│ │ │ │ │ │ S::Partition}:execute-api:${ │
│ │ │ │ │ │ AWS::Region}:${AWS::AccountI │
│ │ │ │ │ │ d}:${RestApi0C43BF4B}/test-i │
│ │ │ │ │ │ nvoke-stage/*/" │
│ │ │ │ │ │ } │
├───┼─────────────────────────────┼────────┼─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤
│ + │ ${LambdaFunctionServiceRole │ Allow │ sts:AssumeRole │ Service:lambda.amazonaws.co │ │
│ │ .Arn} │ │ │ m │ │
├───┼─────────────────────────────┼────────┼─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤
│ + │ ${LambdaRestApiCloudWatchRo │ Allow │ sts:AssumeRole │ Service:apigateway.amazonaw │ │
│ │ le.Arn} │ │ │ s.com │ │
├───┼─────────────────────────────┼────────┼─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤
│ + │ arn:aws:logs:${AWS::Region} │ Allow │ logs:CreateLogGroup │ AWS:${LambdaRestApiCloudWat │ │
│ │ :${AWS::AccountId}:* │ │ logs:CreateLogStream │ chRole} │ │
│ │ │ │ logs:DescribeLogGroups │ │ │
│ │ │ │ logs:DescribeLogStreams │ │ │
│ │ │ │ logs:FilterLogEvents │ │ │
│ │ │ │ logs:GetLogEvents │ │ │
│ │ │ │ logs:PutLogEvents │ │ │
├───┼─────────────────────────────┼────────┼─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤
│ + │ arn:aws:logs:${AWS::Region} │ Allow │ logs:CreateLogGroup │ AWS:${LambdaFunctionService │ │
│ │ :${AWS::AccountId}:log-grou │ │ logs:CreateLogStream │ Role} │ │
│ │ p:/aws/lambda/* │ │ logs:PutLogEvents │ │ │
└───┴─────────────────────────────┴────────┴─────────────────────────────┴─────────────────────────────┴──────────────────────────────┘
(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)
Parameters
[+] Parameter AssetParameters/ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a/S3Bucket AssetParametersba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340aS3Bucket9780A3BC: {"Type":"String","Description":"S3 bucket for asset \"ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a\""}
[+] Parameter AssetParameters/ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a/S3VersionKey AssetParametersba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340aS3VersionKey37F36FFB: {"Type":"String","Description":"S3 key for asset version \"ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a\""}
[+] Parameter AssetParameters/ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a/ArtifactHash AssetParametersba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340aArtifactHash80199FBC: {"Type":"String","Description":"Artifact hash for asset \"ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a\""}
Conditions
[+] Condition CDKMetadataAvailable: {"Fn::Or":[{"Fn::Or":[{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-east-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-northeast-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-northeast-2"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-south-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-southeast-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-southeast-2"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ca-central-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"cn-north-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"cn-northwest-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"eu-central-1"]}]},{"Fn::Or":[{"Fn::Equals":[{"Ref":"AWS::Region"},"eu-north-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"eu-west-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"eu-west-2"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"eu-west-3"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"me-south-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"sa-east-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"us-east-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"us-east-2"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"us-west-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"us-west-2"]}]}]}
Resources
[+] AWS::Logs::LogGroup ApiGatewayToLambda/ApiAccessLogGroup ApiGatewayToLambdaApiAccessLogGroupE2B41502
[+] AWS::IAM::Role LambdaFunctionServiceRole LambdaFunctionServiceRole0C4CDE0B
[+] AWS::Lambda::Function LambdaFunction LambdaFunctionBF21E41F
[+] AWS::ApiGateway::RestApi RestApi RestApi0C43BF4B
[+] AWS::ApiGateway::Deployment RestApi/Deployment RestApiDeployment180EC503d2c6df3c8dc8b7193b98c1a0bff4e677
[+] AWS::ApiGateway::Stage RestApi/DeploymentStage.prod RestApiDeploymentStageprod3855DE66
[+] AWS::ApiGateway::Resource RestApi/Default/{proxy+} RestApiproxyC95856DD
[+] AWS::Lambda::Permission RestApi/Default/{proxy+}/ANY/ApiPermission.HelloConstructsStackRestApiFDB18C2E.ANY..{proxy+} RestApiproxyANYApiPermissionHelloConstructsStackRestApiFDB18C2EANYproxyE43D39B3
[+] AWS::Lambda::Permission RestApi/Default/{proxy+}/ANY/ApiPermission.Test.HelloConstructsStackRestApiFDB18C2E.ANY..{proxy+} RestApiproxyANYApiPermissionTestHelloConstructsStackRestApiFDB18C2EANYproxy0B23CDC7
[+] AWS::ApiGateway::Method RestApi/Default/{proxy+}/ANY RestApiproxyANY1786B242
[+] AWS::Lambda::Permission RestApi/Default/ANY/ApiPermission.HelloConstructsStackRestApiFDB18C2E.ANY.. RestApiANYApiPermissionHelloConstructsStackRestApiFDB18C2EANY5684C1E6
[+] AWS::Lambda::Permission RestApi/Default/ANY/ApiPermission.Test.HelloConstructsStackRestApiFDB18C2E.ANY.. RestApiANYApiPermissionTestHelloConstructsStackRestApiFDB18C2EANY81DBDF56
[+] AWS::ApiGateway::Method RestApi/Default/ANY RestApiANYA7C1DC94
[+] AWS::ApiGateway::UsagePlan RestApi/UsagePlan RestApiUsagePlan6E1C537A
[+] AWS::Logs::LogGroup ApiAccessLogGroup ApiAccessLogGroupCEA70788
[+] AWS::IAM::Role LambdaRestApiCloudWatchRole LambdaRestApiCloudWatchRoleF339D4E6
[+] AWS::ApiGateway::Account LambdaRestApiAccount LambdaRestApiAccount
Outputs
[+] Output RestApi/Endpoint RestApiEndpoint0551178A: {"Value":{"Fn::Join":["",["https://",{"Ref":"RestApi0C43BF4B"},".execute-api.",{"Ref":"AWS::Region"},".",{"Ref":"AWS::URLSuffix"},"/",{"Ref":"RestApiDeploymentStageprod3855DE66"},"/"]]}}
```
Isso é legal. Este exemplo simples, com um padrão bem arquitetado do AWS Solutions Constructs, adicionou 21 novos recursos à sua pilha.
## Implantação cdk
**dica**
Antes de implantar seu primeiro aplicativo CDK da AWS que contém uma função do Lambda, você deve inicializar seu ambiente da AWS. Isso cria um bucket de preparação que o AWS CDK usa para implantar pilhas contendo ativos. Se esta for a primeira vez que você estiver usando o AWS CDK para implantar ativos, será necessário executar o`cdk bootstrap`para implantar a pilha do CDK Toolkit em seu ambiente da AWS.
Pronto para implantar?
```
cdk deploy
```
## Saídas da pilha
Quando a implantação estiver concluída, você notará esta linha:
```
Outputs:
HelloConstructsStack.RestApiEndpoint0551178A = https://{{xxxxxxxxxx}}.execute-api.us-east-1.amazonaws.com/prod/
```
Esta é uma saída de pilha que é automaticamente adicionada pelo padrão AWS Solutions Constructs e inclui a URL do endpoint do API Gateway.
## Testar seu aplicativo
Vamos tentar acertar esse endpoint com`curl`. Copie o URL e execute (seu prefixo e região provavelmente serão diferentes).
```
curl https://{{xxxxxxxxxx}}.execute-api.us-east-1.amazonaws.com/prod/
```
O resultado deve ser semelhante ao seguinte:
```
Hello, AWS Solutions Constructs! You've hit /
```
Se esta é a saída que você recebeu, seu aplicativo funciona\!