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á.
# Conceitos básicos do AWS Solutions Constructs
Este tópico descreve como instalar e configurar o AWS Cloud Development Kit (AWS CDK), o AWS Solutions Constructs e criar seu primeiro aplicativo AWS CDK usando os padrões do AWS Solutions Constructs.
**nota**
Constritos de soluções da AWS são compatíveis com versões do AWS CDK ≥ 1.46.0.
**dica**
Quer cavar mais fundo? Experimente a[Workshop CDK](https://cdkworkshop.com/)para uma excursão mais aprofundada de um projeto do mundo real.
**dica**
Para obter mais informações sobre como começar a usar o Cloud Development Kit AWS (AWS CDK), consulte a[Guia do desenvolvedor do AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html).
## Prerequisites
O AWS Solutions Constructs é construído com base no AWS CDK, portanto, você precisa instalar o Node.js (>= 10.3.0), mesmo aqueles que trabalham em idiomas diferentes do TypeScript ou JavaScript. Isso ocorre porque o[AWS CDK](https://github.com/aws/aws-cdk)e AWS Solutions Constructs são desenvolvidos em TypeScript e executados em Node.js. As ligações para outros idiomas suportados usam este backend e conjunto de ferramentas.
Você deve fornecer suas credenciais e uma região da AWS para usar o AWS CDK CLI, conforme descrito em Especificando suas credenciais e região.
Outros pré-requisitos dependem da sua linguagem de desenvolvimento, como se segue.
| **Linguagem** | **Pré-requisitos** |
| --- | --- |
| ![\[Python\]](http://docs.aws.amazon.com/pt_br/solutions/latest/constructs/images/python.png)Python | Python >= 3.6 |
| ![\[TypeScript\]](http://docs.aws.amazon.com/pt_br/solutions/latest/constructs/images/typescript.png)TypeScript | Texto TypeScript >= 2.7 |
| ![\[Java\]](http://docs.aws.amazon.com/pt_br/solutions/latest/constructs/images/java.png)Java | Java >= 1.8 |
## Instalar o AWS CDK
Para instalar e configurar o AWS CDK, consulte o AWS CDK Developer Guide -[Instalar o AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_install).
## Trabalhar com construções de soluções da AWS
O fluxo de trabalho típico para criar um novo aplicativo ao trabalhar com o AWS Solutions Constructs segue a mesma abordagem que o AWS CDK.
1. Crie o diretório do aplicativo.
1. Inicialize o aplicativo.
1. Adicione as dependências de padrão do AWS Solutions Constructs.
1. Adicione código adicional ao aplicativo.
1. Compilar o aplicativo, se necessário.
1. Implante os recursos definidos no aplicativo.
1. Testar o aplicativo.
Se houver algum problema, faça o loop através de modificar, compilar (se necessário), implantar e testar novamente.
# 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:
![\[Diagrama de arquitetura\]](http://docs.aws.amazon.com/pt_br/solutions/latest/constructs/images/tutorial-part1.png)
## 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\$1 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\$1
# Passo a passo - Parte 2
**nota**
O AWS Solutions Constructs é compatível com versões ≥ 1.46.0 do AWS.
Este tutorial mostra como modificar o aplicativo “Hello Constructs” criado em[parte 1](walkthrough-part-1.md). Nossa modificação adicionará um contador de visitas ao site usando o padrão AWS Lambda ao DynamoDB de Constructs de soluções da AWS. Modificar o aplicativo Hello Constructs resultará na seguinte solução:
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/solutions/latest/constructs/images/tutorial-part2.png)
## Código do Lambda do contador
Vamos começar escrevendo o código para a função Hit Counter AWS Lambda. Essa função irá:
+ incrementar um contador relacionado ao caminho da API em uma tabela do Amazon DynamoDB,
+ invocar a função downstream Hello AWS Lambda,
+ e retorne a resposta ao usuário final.
------
#### [ TypeScript ]
Adicionar um arquivo chamado`lambda/hitcounter.js`com o seguinte conteúdo:
```
const { DynamoDB, Lambda } = require('aws-sdk');
exports.handler = async function(event) {
console.log("request:", JSON.stringify(event, undefined, 2));
// create AWS SDK clients
const dynamo = new DynamoDB();
const lambda = new Lambda();
// update dynamo entry for "path" with hits++
await dynamo.updateItem({
TableName: process.env.DDB_TABLE_NAME,
Key: { path: { S: event.path } },
UpdateExpression: 'ADD hits :incr',
ExpressionAttributeValues: { ':incr': { N: '1' } }
}).promise();
// call downstream function and capture response
const resp = await lambda.invoke({
FunctionName: process.env.DOWNSTREAM_FUNCTION_NAME,
Payload: JSON.stringify(event)
}).promise();
console.log('downstream response:', JSON.stringify(resp, undefined, 2));
// return response back to upstream caller
return JSON.parse(resp.Payload);
};
```
------
#### [ Python ]
Adicionar um arquivo chamado`lambda/hitcounter.py`com o seguinte conteúdo:
```
import json
import os
import boto3
ddb = boto3.resource('dynamodb')
table = ddb.Table(os.environ['DDB_TABLE_NAME'])
_lambda = boto3.client('lambda')
def handler(event, context):
print('request: {}'.format(json.dumps(event)))
table.update_item(
Key={'path': event['path']},
UpdateExpression='ADD hits :incr',
ExpressionAttributeValues={':incr': 1}
)
resp = _lambda.invoke(
FunctionName=os.environ['DOWNSTREAM_FUNCTION_NAME'],
Payload=json.dumps(event),
)
body = resp['Payload'].read()
print('downstream response: {}'.format(body))
return json.loads(body)
```
------
## Instalar as novas dependências
**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. Isso deve ser idêntico ao número de versão usado para dependências na primeira parte deste passo a passo. Versões incompatíveis entre pacotes podem causar erros.
Como de costume, primeiro precisamos instalar as dependências necessárias para a atualização da nossa solução. Primeiro, precisamos instalar a biblioteca de construção do DynamoDB:
------
#### [ TypeScript ]
```
npm install -s @aws-cdk/aws-dynamodb@VERSION_NUMBER
```
------
#### [ Python ]
```
pip install aws_cdk.aws_dynamodb==VERSION_NUMBER
```
------
Por fim, instale os Construtos de soluções da AWS`aws-lambda-dynamodb`e todas as suas dependências em nosso projeto:
------
#### [ TypeScript ]
```
npm install -s @aws-solutions-constructs/aws-lambda-dynamodb@VERSION_NUMBER
```
------
#### [ Python ]
```
pip install aws_solutions_constructs.aws_lambda_dynamodb==VERSION_NUMBER
```
------
## Defina os recursos
Agora, vamos atualizar nosso código de pilha para acomodar nossa nova arquitetura.
Primeiro, vamos importar nossas novas dependências e mover a função “Olá” para fora do`aws-apigateway-lambda`padrão que criamos na parte 1.
------
#### [ 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 * as dynamodb from '@aws-cdk/aws-dynamodb';
import { ApiGatewayToLambda, ApiGatewayToLambdaProps } from '@aws-solutions-constructs/aws-apigateway-lambda';
import { LambdaToDynamoDB, LambdaToDynamoDBProps } from '@aws-solutions-constructs/aws-lambda-dynamodb';
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 helloFunc = new lambda.Function(this, 'HelloHandler', {
runtime: lambda.Runtime.NODEJS_12_X,
code: lambda.Code.fromAsset('lambda'),
handler: 'hello.handler'
});
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,
aws_dynamodb as ddb,
core,
)
from aws_solutions_constructs import (
aws_apigateway_lambda as apigw_lambda,
aws_lambda_dynamodb as lambda_ddb
)
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
self._handler = _lambda.Function(
self, 'HelloHandler',
runtime=_lambda.Runtime.PYTHON_3_7,
handler='hello.handler',
code=_lambda.Code.asset('lambda'),
)
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
)
)
)
```
------
Em seguida, vamos adicionar o`aws-lambda-dynamodb`padrão para construir o serviço de contador de sucesso para nossa arquitetura atualizada.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/solutions/latest/constructs/images/tutorial-part2a.png)
A próxima atualização abaixo define as propriedades para o`aws-lambda-dynamodb`definindo a função do AWS Lambda com o manipulador Hit Counter. Além disso, a tabela do Amazon DynamoDB é definida com um nome de`Hits`e uma chave de partição do`path`.
------
#### [ 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 * as dynamodb from '@aws-cdk/aws-dynamodb';
import { ApiGatewayToLambda, ApiGatewayToLambdaProps } from '@aws-solutions-constructs/aws-apigateway-lambda';
import { LambdaToDynamoDB, LambdaToDynamoDBProps } from '@aws-solutions-constructs/aws-lambda-dynamodb';
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 helloFunc = new lambda.Function(this, 'HelloHandler', {
runtime: lambda.Runtime.NODEJS_12_X,
code: lambda.Code.fromAsset('lambda'),
handler: 'hello.handler'
});
// hit counter, aws-lambda-dynamodb pattern
const lambda_ddb_props: LambdaToDynamoDBProps = {
lambdaFunctionProps: {
code: lambda.Code.asset(`lambda`),
runtime: lambda.Runtime.NODEJS_12_X,
handler: 'hitcounter.handler',
environment: {
DOWNSTREAM_FUNCTION_NAME: helloFunc.functionName
}
},
dynamoTableProps: {
tableName: 'Hits',
partitionKey: { name: 'path', type: dynamodb.AttributeType.STRING }
}
};
const hitcounter = new LambdaToDynamoDB(this, 'LambdaToDynamoDB', lambda_ddb_props);
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,
aws_dynamodb as ddb,
core,
)
from aws_solutions_constructs import (
aws_apigateway_lambda as apigw_lambda,
aws_lambda_dynamodb as lambda_ddb
)
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
self.hello_func = _lambda.Function(
self, 'HelloHandler',
runtime=_lambda.Runtime.PYTHON_3_7,
handler='hello.handler',
code=_lambda.Code.asset('lambda'),
)
# hit counter, aws-lambda-dynamodb pattern
self.hit_counter = lambda_ddb.LambdaToDynamoDB(
self, 'LambdaToDynamoDB',
lambda_function_props=_lambda.FunctionProps(
runtime=_lambda.Runtime.PYTHON_3_7,
code=_lambda.Code.asset('lambda'),
handler='hitcounter.handler',
environment={
'DOWNSTREAM_FUNCTION_NAME': self.hello_func.function_name
}
),
dynamo_table_props=ddb.TableProps(
table_name='Hits',
partition_key={
'name': 'path',
'type': ddb.AttributeType.STRING
}
)
)
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
)
)
)
```
------
Em seguida, precisaremos conceder a função Contador de Hits criada a partir do`aws-lambda-dynamodb`padrão adicionado acima permissão para invocar nossa função Hello.
------
#### [ 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 * as dynamodb from '@aws-cdk/aws-dynamodb';
import { ApiGatewayToLambda, ApiGatewayToLambdaProps } from '@aws-solutions-constructs/aws-apigateway-lambda';
import { LambdaToDynamoDB, LambdaToDynamoDBProps } from '@aws-solutions-constructs/aws-lambda-dynamodb';
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
// hello function responding to http requests
const helloFunc = new lambda.Function(this, 'HelloHandler', {
runtime: lambda.Runtime.NODEJS_12_X,
code: lambda.Code.fromAsset('lambda'),
handler: 'hello.handler'
});
// hit counter, aws-lambda-dynamodb pattern
const lambda_ddb_props: LambdaToDynamoDBProps = {
lambdaFunctionProps: {
code: lambda.Code.asset(`lambda`),
runtime: lambda.Runtime.NODEJS_12_X,
handler: 'hitcounter.handler',
environment: {
DOWNSTREAM_FUNCTION_NAME: helloFunc.functionName
}
},
dynamoTableProps: {
tableName: 'Hits',
partitionKey: { name: 'path', type: dynamodb.AttributeType.STRING }
}
};
const hitcounter = new LambdaToDynamoDB(this, 'LambdaToDynamoDB', lambda_ddb_props);
// grant the hitcounter lambda role invoke permissions to the hello function
helloFunc.grantInvoke(hitcounter.lambdaFunction);
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,
aws_dynamodb as ddb,
core,
)
from aws_solutions_constructs import (
aws_apigateway_lambda as apigw_lambda,
aws_lambda_dynamodb as lambda_ddb
)
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
self.hello_func = _lambda.Function(
self, 'HelloHandler',
runtime=_lambda.Runtime.PYTHON_3_7,
handler='hello.handler',
code=_lambda.Code.asset('lambda'),
)
# hit counter, aws-lambda-dynamodb pattern
self.hit_counter = lambda_ddb.LambdaToDynamoDB(
self, 'LambdaToDynamoDB',
lambda_function_props=_lambda.FunctionProps(
runtime=_lambda.Runtime.PYTHON_3_7,
code=_lambda.Code.asset('lambda'),
handler='hitcounter.handler',
environment={
'DOWNSTREAM_FUNCTION_NAME': self.hello_func.function_name
}
),
dynamo_table_props=ddb.TableProps(
table_name='Hits',
partition_key={
'name': 'path',
'type': ddb.AttributeType.STRING
}
)
)
# grant the hitcounter lambda role invoke permissions to the hello function
self.hello_func.grant_invoke(self.hit_counter.lambda_function)
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
)
)
)
```
------
Finalmente, precisamos atualizar nosso original`aws-apigateway-lambda`para utilizar nossa nova função Hit Counter que foi provisionada com o`aws-lambda-dynamodb`Padrão acima.
------
#### [ 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 * as dynamodb from '@aws-cdk/aws-dynamodb';
import { ApiGatewayToLambda, ApiGatewayToLambdaProps } from '@aws-solutions-constructs/aws-apigateway-lambda';
import { LambdaToDynamoDB, LambdaToDynamoDBProps } from '@aws-solutions-constructs/aws-lambda-dynamodb';
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
// hello function responding to http requests
const helloFunc = new lambda.Function(this, 'HelloHandler', {
runtime: lambda.Runtime.NODEJS_12_X,
code: lambda.Code.fromAsset('lambda'),
handler: 'hello.handler'
});
// hit counter, aws-lambda-dynamodb pattern
const lambda_ddb_props: LambdaToDynamoDBProps = {
lambdaFunctionProps: {
code: lambda.Code.asset(`lambda`),
runtime: lambda.Runtime.NODEJS_12_X,
handler: 'hitcounter.handler',
environment: {
DOWNSTREAM_FUNCTION_NAME: helloFunc.functionName
}
},
dynamoTableProps: {
tableName: 'Hits',
partitionKey: { name: 'path', type: dynamodb.AttributeType.STRING }
}
};
const hitcounter = new LambdaToDynamoDB(this, 'LambdaToDynamoDB', lambda_ddb_props);
// grant the hitcounter lambda role invoke permissions to the hello function
helloFunc.grantInvoke(hitcounter.lambdaFunction);
const api_lambda_props: ApiGatewayToLambdaProps = {
existingLambdaObj: hitcounter.lambdaFunction,
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,
aws_dynamodb as ddb,
core,
)
from aws_solutions_constructs import (
aws_apigateway_lambda as apigw_lambda,
aws_lambda_dynamodb as lambda_ddb
)
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
self.hello_func = _lambda.Function(
self, 'HelloHandler',
runtime=_lambda.Runtime.PYTHON_3_7,
handler='hello.handler',
code=_lambda.Code.asset('lambda'),
)
# hit counter, aws-lambda-dynamodb pattern
self.hit_counter = lambda_ddb.LambdaToDynamoDB(
self, 'LambdaToDynamoDB',
lambda_function_props=_lambda.FunctionProps(
runtime=_lambda.Runtime.PYTHON_3_7,
code=_lambda.Code.asset('lambda'),
handler='hitcounter.handler',
environment={
'DOWNSTREAM_FUNCTION_NAME': self.hello_func.function_name
}
),
dynamo_table_props=ddb.TableProps(
table_name='Hits',
partition_key={
'name': 'path',
'type': ddb.AttributeType.STRING
}
)
)
# grant the hitcounter lambda role invoke permissions to the hello function
self.hello_func.grant_invoke(self.hit_counter.lambda_function)
apigw_lambda.ApiGatewayToLambda(
self, 'ApiGatewayToLambda',
existing_lambda_obj=self.hit_counter.lambda_function,
api_gateway_props=apigw.RestApiProps(
default_method_options=apigw.MethodOptions(
authorization_type=apigw.AuthorizationType.NONE
)
)
)
```
------
## Review as alterações
Vamos construir nosso projeto e revisar as alterações em nossos recursos que acontecerão quando implantarmos isso:
```
npm run build
cdk diff
```
Nossa saída deve ser semelhante a esta:
```
Stack HelloConstructsStack
IAM Statement Changes
┌───┬───────────────────────────────────┬────────┬───────────────────────────────────┬────────────────────────────────────┬───────────┐
│ │ Resource │ Effect │ Action │ Principal │ Condition │
├───┼───────────────────────────────────┼────────┼───────────────────────────────────┼────────────────────────────────────┼───────────┤
│ + │ ${HelloHandler.Arn} │ Allow │ lambda:InvokeFunction │ AWS:${LambdaFunctionServiceRole} │ │
├───┼───────────────────────────────────┼────────┼───────────────────────────────────┼────────────────────────────────────┼───────────┤
│ + │ ${HelloHandler/ServiceRole.Arn} │ Allow │ sts:AssumeRole │ Service:lambda.amazonaws.com │ │
├───┼───────────────────────────────────┼────────┼───────────────────────────────────┼────────────────────────────────────┼───────────┤
│ + │ ${LambdaToDynamoDB/DynamoTable.Ar │ Allow │ dynamodb:BatchGetItem │ AWS:${LambdaFunctionServiceRole} │ │
│ │ n} │ │ dynamodb:BatchWriteItem │ │ │
│ │ │ │ dynamodb:DeleteItem │ │ │
│ │ │ │ dynamodb:GetItem │ │ │
│ │ │ │ dynamodb:GetRecords │ │ │
│ │ │ │ dynamodb:GetShardIterator │ │ │
│ │ │ │ dynamodb:PutItem │ │ │
│ │ │ │ dynamodb:Query │ │ │
│ │ │ │ dynamodb:Scan │ │ │
│ │ │ │ dynamodb:UpdateItem │ │ │
└───┴───────────────────────────────────┴────────┴───────────────────────────────────┴────────────────────────────────────┴───────────┘
IAM Policy Changes
┌───┬─────────────────────────────┬────────────────────────────────────────────────────────────────────────────────┐
│ │ Resource │ Managed Policy ARN │
├───┼─────────────────────────────┼────────────────────────────────────────────────────────────────────────────────┤
│ + │ ${HelloHandler/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)
Resources
[+] AWS::IAM::Role HelloHandler/ServiceRole HelloHandlerServiceRole11EF7C63
[+] AWS::Lambda::Function HelloHandler HelloHandler2E4FBA4D
[+] AWS::DynamoDB::Table LambdaToDynamoDB/DynamoTable LambdaToDynamoDBDynamoTable53C1442D
[+] AWS::IAM::Policy LambdaFunctionServiceRole/DefaultPolicy LambdaFunctionServiceRoleDefaultPolicy126C8897
[~] AWS::Lambda::Function LambdaFunction LambdaFunctionBF21E41F
├─ [+] Environment
│ └─ {"Variables":{"DOWNSTREAM_FUNCTION_NAME":{"Ref":"HelloHandler2E4FBA4D"},"DDB_TABLE_NAME":{"Ref":"LambdaToDynamoDBDynamoTable53C1442D"}}}
├─ [~] Handler
│ ├─ [-] hello.handler
│ └─ [+] hitcounter.handler
└─ [~] DependsOn
└─ @@ -1,3 +1,4 @@
[ ] [
[+] "LambdaFunctionServiceRoleDefaultPolicy126C8897",
[ ] "LambdaFunctionServiceRole0C4CDE0B"
[ ] ]
```
## Implantação cdk
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/
```
## Testar seu aplicativo
Vamos tentar acertar este ponto final 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 /
```
Agora, vamos revisar o`Hits`Tabela do Amazon DynamoDB.
1. Acesse o console do DynamoDB.
1. Verifique se você está na Região onde criou a tabela.
1. Select**Tabelas**no painel de navegação e selecione a caixa de seleção**Hits**Tabela INTO.
1. Abra a tabela e selecione “Itens”.
1. Você deve ver quantos hits você tem para cada caminho.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/solutions/latest/constructs/images/tutorial-part2b.png)
1. Tente acertar um novo caminho e atualize a exibição Itens. Você verá um novo item com um`hits`contagem de um.
Se esta é a saída que você recebeu, seu aplicativo funciona\$1
# Casos de uso do
Esta biblioteca inclui uma coleção de implementações de caso de uso funcional para demonstrar o uso de padrões arquitetônicos de construções. Estes podem ser usados da mesma maneira que os padrões arquitetônicos, e podem ser conceituados como uma abstração adicional de “nível superior” desses padrões. Os seguintes casos de uso são fornecidos como exemplos funcionais:
## Site do AWS Static S3
Este padrão de caso de uso (`aws-s3-static-website`) implementa uma distribuição do Amazon CloudFront, bucket do Amazon S3 e recurso personalizado baseado no AWS Lambda para copiar o conteúdo estático do site de demonstração do Wild Rydes (parte do`aws-serverless-web-app`implementação do.
**Código Fonte (aws-s3-static-website)**
[https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use\$1cases/aws-s3-static-website](https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use_cases/aws-s3-static-website)
## Manipulador de imagens simples sem servidor da AWS
Este padrão de caso de uso (`aws-serverless-image-handler`) implementa uma distribuição do Amazon CloudFront, uma API REST do Amazon API Gateway, uma função do AWS Lambda e permissões/lógicas necessárias para provisionar uma API de manipulador de imagem funcional para servir conteúdo de imagem de um ou mais buckets do Amazon S3 na conta de implantação.
**Código fonte (aws-serverless-image-handler)**
[https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use\$1cases/aws-serverless-image-handler](https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use_cases/aws-serverless-image-handler)
## Aplicativo web sem servidor da AWS
Este padrão de caso de uso (`aws-serverless-web-app`) implementa um simples aplicativo web sem servidor que permite aos usuários solicitar passeios de unicórnio da frota Wild Rydes. O aplicativo apresentará aos usuários uma interface de usuário baseada em HTML para indicar o local onde eles gostariam de ser retirados e fará interface no backend com um serviço Web RESTful para enviar a solicitação e enviar um unicórnio próximo. O aplicativo também fornecerá recursos para que os usuários se registrem no serviço e façam login antes de solicitar viagens.
**Código fonte (aws-serverless-web-app)**
[https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use\$1cases/aws-serverless-web-app](https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use_cases/aws-serverless-web-app)