Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di AWS Solutions Constructs
In questo argomento viene descritto come installare e configurare AWS Cloud Development Kit (AWS CDK), AWS Solutions Constructs e creare la prima app AWS CDK utilizzando i modelli AWS Solutions Constructs.
**Nota**
AWS Solutions Constructs è supportato su AWS CDK versioni ≥ 1.46.0.
**Suggerimento**
Vuoi scavare più a fondo? Prova la[Workshop CDK](https://cdkworkshop.com/)per un tour più approfondito di un progetto del mondo reale.
**Suggerimento**
Per ulteriori informazioni su come usare l'AWS Cloud Development Kit (AWS CDK), consulta la[Guida per sviluppatori di AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html): .
## Prerequisites
AWS Solutions Constructs è basato su AWS CDK, quindi è necessario installare Node.js (> = 10.3.0), anche quelli che lavorano in lingue diverse da TypeScript o JavaScript. Questo perché il[AWS CDK](https://github.com/aws/aws-cdk)e AWS Solutions Constructs sono sviluppati in TypeScript ed eseguiti su Node.js. I binding per altre lingue supportate utilizzano questo back-end e toolset.
È necessario fornire le credenziali e un'area AWS per utilizzare l'interfaccia della riga di comando CDK di AWS, come descritto in Specifica delle credenziali e dell'area geografica.
Altri prerequisiti dipendono dal linguaggio di sviluppo, come indicato di seguito.
| **Linguaggio** | **Prerequisiti** |
| --- | --- |
| ![\[Python\]](http://docs.aws.amazon.com/it_it/solutions/latest/constructs/images/python.png)Python | Python >= 3.6 |
| ![\[TypeScript\]](http://docs.aws.amazon.com/it_it/solutions/latest/constructs/images/typescript.png)TypeScript | TypeScript >= 2.7 |
| ![\[Java\]](http://docs.aws.amazon.com/it_it/solutions/latest/constructs/images/java.png)Java | Java >= 1.8 |
## Installazione di AWS CDK
Per installare e configurare AWS CDK, fare riferimento alla Guida per sviluppatori CDK AWS -[Installazione di AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_install): .
## Utilizzo di AWS Solutions Constructs
Il flusso di lavoro tipico per la creazione di una nuova app quando si lavora con AWS Solutions Constructs segue lo stesso approccio di AWS CDK.
1. Creare la directory dell'app.
1. Inizializzare l'app.
1. Aggiungere le dipendenze del modello AWS Solutions Constructs.
1. Aggiungi codice aggiuntivo all'app.
1. Compilare l'app, se necessario.
1. Distribuisci le risorse definite nell'app.
1. Eseguire il test dell'app.
Se ci sono problemi, eseguire il ciclo attraverso la modifica, compilare (se necessario), distribuire e testare nuovamente.
# Procedura dettagliata - Parte 1
**Nota**
Costrutti di AWS Solutions è supportato sulle versioni CDK ≥ 1.46.0.
Questo tutorial illustra come creare e distribuire una semplice app AWS CDK «Hello Constructs» che utilizza un modello di AWS Solutions Constructs, dall'inizializzazione del progetto alla distribuzione del modello AWS CloudFormation risultante. L'app Hello Constructs creerà la seguente semplice soluzione:
![\[Diagramma dell'architettura\]](http://docs.aws.amazon.com/it_it/solutions/latest/constructs/images/tutorial-part1.png)
## Costrutti di Hello
Iniziamo a costruire la nostra prima app CDK AWS utilizzando lo sviluppo basato su pattern.
**Nota**
Questa è una modifica di esempio di`Hello CDK!`dagli[Workshop CDK](https://cdkworkshop.com/): . Se questa è la prima volta che utilizzi AWS CDK, ti consigliamo di iniziare con questo workshop per una procedura dettagliata pratica e come sfruttare il CDK nella costruzione di un progetto reale.
## Creazione della directory delle app e inizializzazione del CDK AWS
Creare una directory per l'app CDK e quindi creare un'app AWS CDK in tale directory.
------
#### [ TypeScript ]
```
mkdir hello-constructs
cd hello-constructs
cdk init --language typescript
```
------
#### [ Python ]
```
mkdir hello-constructs
cd hello-constructs
cdk init --language python
```
------
**Suggerimento**
Ora è il momento giusto per aprire il progetto nel tuo IDE preferito ed esplorare. Per ulteriori informazioni sulla struttura del progetto, seleziona il collegamento appropriato:
[TypeScript](https://cdkworkshop.com/20-typescript/20-create-project/300-structure.html)
[Python](https://cdkworkshop.com/30-python/20-create-project/300-structure.html)
## Aggiorna le dipendenze di base di
**avvertimento**
Per garantire la corretta funzionalità, AWS Solutions Constructs e AWS CDK pacchetti devono utilizzare lo stesso numero di versione all'interno del progetto. Ad esempio, se si utilizza AWS Solutions Constructs v.1.52.0, è necessario utilizzare anche AWS CDK v.1.52.0.
**Suggerimento**
Prendere nota della versione più recente di AWS Solutions Constructs e applicare tale numero di versione al`VERSION_NUMBER`nella procedura riportata di seguito (sia per AWS Solutions Constructs che per i pacchetti AWS CDK). Per controllare tutte le versioni pubbliche della libreria Costrutts,[Fare clic qui](https://github.com/awslabs/aws-solutions-constructs/releases): .
------
#### [ TypeScript ]
Modificare il file`package.json`con le seguenti informazioni:
```
"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 ]
Modificare il file`setup.py`con le seguenti informazioni:
```
install_requires=[
"aws-cdk.core==VERSION_NUMBER",
],
```
------
Installare le dipendenze di base dei progetti.
------
#### [ TypeScript ]
```
npm install
```
------
#### [ Python ]
```
source .venv/bin/activate
pip install -r requirements.txt
```
------
Crea ed esegui l'app e conferma che crea uno stack vuoto.
------
#### [ TypeScript ]
```
npm run build
cdk synth
```
------
#### [ Python ]
```
cdk synth
```
------
Dovresti vedere uno stack come il seguente, dove`CDK-VERSION`è la versione del CDK. (Il tuo output potrebbe differire leggermente da quello mostrato qui.)
------
#### [ 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
```
------
## Codice del gestore Lambda
Inizieremo con il codice gestore AWS Lambda.
Creazione di una directory`lambda`nella directory root dell'albero del progetto.
------
#### [ TypeScript ]
Aggiungere un file denominato`lambda/hello.js`con i seguenti contenuti:
```
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 ]
Aggiungere un file denominato`lambda/hello.py`con i seguenti contenuti:
```
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'])
}
```
------
Questa è una semplice funzione Lambda che restituisce il testo «Ciao, costrutti\$1 Hai colpito [url path]». L'output della funzione include anche il codice di stato HTTP e le intestazioni HTTP. Questi vengono utilizzati da API Gateway per formulare la risposta HTTP all'utente.
Questa Lambda è fornita in JavaScript. Per ulteriori informazioni sulla scrittura delle funzioni Lambda nella lingua di scelta, fare riferimento alla[Documentazione AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): .
## Installare le dipendenze di AWS CDK e AWS Solutions Constructs
AWS Solutions Constructs viene fornito con una vasta libreria di costrutti. La libreria è divisa in moduli, uno per ogni modello ben progettato. Ad esempio, se si desidera definire un'Amazon API Gateway Rest API per una funzione AWS Lambda, sarà necessario utilizzare il`aws-apigateway-lambda`Libreria di pattern.
Abbiamo anche bisogno di aggiungere la libreria di costrutto AWS Lambda e Amazon API Gateway dal CDK AWS.
Installa il modulo AWS Lambda e tutte le sue dipendenze nel nostro progetto:
**Nota**
Ricordarsi di sostituire la versione corretta e corrispondente da utilizzare sia per AWS Solutions Constructs che per AWS CDK nel`VERSION_NUMBER`campi segnaposto per ogni comando. La mancata corrispondenza delle versioni tra i pacchetti può causare errori.
------
#### [ TypeScript ]
```
npm install -s @aws-cdk/aws-lambda@VERSION_NUMBER
```
------
#### [ Python ]
```
pip install aws_cdk.aws_lambda==VERSION_NUMBER
```
------
Successivamente, installa il modulo Amazon API Gateway e tutte le sue dipendenze nel nostro progetto:
------
#### [ TypeScript ]
```
npm install -s @aws-cdk/aws-apigateway@VERSION_NUMBER
```
------
#### [ Python ]
```
pip install aws_cdk.aws_apigateway==VERSION_NUMBER
```
------
Infine, installa i costrutti di soluzioni AWS`aws-apigateway-lambda`e tutte le sue dipendenze nel nostro progetto:
------
#### [ TypeScript ]
```
npm install -s @aws-solutions-constructs/aws-apigateway-lambda@VERSION_NUMBER
```
------
#### [ Python ]
```
pip install aws_solutions_constructs.aws_apigateway_lambda==VERSION_NUMBER
```
------
## Aggiungi un gateway API Amazon/modello AWS Lambda al tuo stack
Ora, definiamo il modello AWS Solutions Constructs per l'implementazione di un Amazon API Gateway con un proxy AWS Lambda.
------
#### [ TypeScript ]
Modificare il file`lib/hello-constructs.ts`con gli elementi seguenti:
```
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 ]
Modificare il file`hello_constructs/hello_constructs_stack.py`con gli elementi seguenti:
```
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
)
)
)
```
------
Questo è tutto. Questo è tutto ciò che devi fare per definire un API Gateway che proxy tutte le richieste a una funzione AWS Lambda. Confrontiamo il nostro nuovo stack con quello originale:
------
#### [ TypeScript ]
```
npm run build
cdk diff
```
------
#### [ Python ]
```
cdk diff
```
------
L'output dovrebbe essere simile al seguente:
```
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"},"/"]]}}
```
Che bello. Questo semplice esempio con un modello ben progettato da AWS Solutions Constructs ha aggiunto 21 nuove risorse al tuo stack.
## Distribuzione di cdk
**Suggerimento**
Prima di poter distribuire la prima app AWS CDK contenente una funzione Lambda, è necessario eseguire il bootstrap dell'ambiente AWS. Questo crea un bucket di gestione temporanea che AWS CDK utilizza per distribuire stack contenenti risorse. Se questa è la prima volta che si utilizza AWS CDK per distribuire le risorse, sarà necessario eseguire il comando`cdk bootstrap`per distribuire lo stack di toolkit CDK nel tuo ambiente AWS.
Pronti per la distribuzione?
```
cdk deploy
```
## Output dello stack
Al termine della distribuzione, noterai questa riga:
```
Outputs:
HelloConstructsStack.RestApiEndpoint0551178A = https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/prod/
```
Si tratta di un output dello stack che viene aggiunto automaticamente dal modello AWS Solutions Constructs e include l'URL dell'endpoint del API Gateway.
## Esecuzione del test dell'app
Proviamo a colpire questo endpoint con`curl`: . Copia l'URL ed esegui (il tuo prefisso e la tua regione saranno probabilmente diversi).
```
curl https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/prod/
```
L'output dovrebbe essere simile al seguente:
```
Hello, AWS Solutions Constructs! You've hit /
```
Se questo è l'output che hai ricevuto, la tua app funziona\$1
# Procedura dettagliata - Parte 2
**Nota**
AWS Solutions Constructs è supportato sulle versioni CDK ≥ 1.46.0.
Questo tutorial illustra come modificare l'app «Hello Constructs» creata in[PART 1](walkthrough-part-1.md): . La nostra modifica aggiungerà un contatore di visite del sito utilizzando il modello AWS Lambda a DynamoDB da AWS Solutions Constructs. La modifica dell'app Hello Constructs si tradurrà nella seguente soluzione:
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/solutions/latest/constructs/images/tutorial-part2.png)
## Codice Lambda del contatore di colpo
Iniziamo scrivendo il codice per la funzione Hit Counter AWS Lambda. Questa funzione:
+ incrementare un contatore correlato al percorso API in una tabella Amazon DynamoDB,
+ richiamare la funzione Hello AWS Lambda a valle,
+ e restituire la risposta all'utente finale.
------
#### [ TypeScript ]
Aggiungere un file denominato`lambda/hitcounter.js`con i seguenti contenuti:
```
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 ]
Aggiungere un file denominato`lambda/hitcounter.py`con i seguenti contenuti:
```
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)
```
------
## Installare le nuove dipendenze
**Nota**
Ricordarsi di sostituire la versione corretta e corrispondente da utilizzare sia per AWS Solutions Constructs che per AWS CDK nel`VERSION_NUMBER`campi segnaposto per ogni comando. Questo dovrebbe essere identico al numero di versione utilizzato per le dipendenze nella prima parte di questa procedura dettagliata. La mancata corrispondenza delle versioni tra i pacchetti può causare errori.
Come al solito, dobbiamo prima installare le dipendenze di cui abbiamo bisogno per l'aggiornamento della nostra soluzione. Innanzitutto, dobbiamo installare la libreria di costrutto DynamoDB:
------
#### [ TypeScript ]
```
npm install -s @aws-cdk/aws-dynamodb@VERSION_NUMBER
```
------
#### [ Python ]
```
pip install aws_cdk.aws_dynamodb==VERSION_NUMBER
```
------
Infine, installa i costrutti di soluzioni AWS`aws-lambda-dynamodb`e tutte le sue dipendenze nel nostro progetto:
------
#### [ TypeScript ]
```
npm install -s @aws-solutions-constructs/aws-lambda-dynamodb@VERSION_NUMBER
```
------
#### [ Python ]
```
pip install aws_solutions_constructs.aws_lambda_dynamodb==VERSION_NUMBER
```
------
## Definisci le risorse
Ora, aggiorniamo il nostro codice di stack per accogliere la nostra nuova architettura.
Innanzitutto, importeremo le nostre nuove dipendenze e sposteremo la funzione «Ciao» al di fuori del`aws-apigateway-lambda`abbiamo creato nella parte 1.
------
#### [ TypeScript ]
Modificare il file`lib/hello-constructs.ts`con gli elementi seguenti:
```
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 ]
Modificare il file`hello_constructs/hello_constructs_stack.py`con gli elementi seguenti:
```
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
)
)
)
```
------
Successivamente, aggiungeremo il`aws-lambda-dynamodb`per costruire il servizio di contatore degli accessi per la nostra architettura aggiornata.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/solutions/latest/constructs/images/tutorial-part2a.png)
Il prossimo aggiornamento di seguito definisce le proprietà per il`aws-lambda-dynamodb`definendo la funzione AWS Lambda con il gestore Hit Counter. Inoltre, la tabella Amazon DynamoDB è definita con il nome`Hits`e una chiave di partizione di`path`: .
------
#### [ TypeScript ]
Modificare il file`lib/hello-constructs.ts`con gli elementi seguenti:
```
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 ]
Modificare il file`hello_constructs/hello_constructs_stack.py`con gli elementi seguenti:
```
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
)
)
)
```
------
Successivamente, dobbiamo concedere la funzione Hit Counter creata dalla`aws-lambda-dynamodb`aggiunto sopra il permesso di richiamare la nostra funzione Hello.
------
#### [ TypeScript ]
Modificare il file`lib/hello-constructs.ts`con gli elementi seguenti:
```
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 ]
Modificare il file`hello_constructs/hello_constructs_stack.py`con gli elementi seguenti:
```
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
)
)
)
```
------
Infine, abbiamo bisogno di aggiornare il nostro`aws-apigateway-lambda`per utilizzare la nostra nuova funzione Hit Counter che è stata fornita con`aws-lambda-dynamodb`Modello di cui sopra.
------
#### [ TypeScript ]
Modificare il file`lib/hello-constructs.ts`con gli elementi seguenti:
```
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 ]
Modificare il file`hello_constructs/hello_constructs_stack.py`con gli elementi seguenti:
```
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 Changes
Costruiamo il nostro progetto ed esaminiamo le modifiche alle nostre risorse che avverranno quando implementeremo questo:
```
npm run build
cdk diff
```
Il nostro output dovrebbe essere simile al seguente:
```
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"
[ ] ]
```
## Distribuzione cdk
Ok, pronto per la distribuzione?
```
cdk deploy
```
## Output dello stack
Al termine della distribuzione, noterai questa riga:
```
Outputs:
HelloConstructsStack.RestApiEndpoint0551178A = https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/prod/
```
## Esecuzione del test dell'app
Proviamo a colpire questo endpoint con arricciatura. Copia l'URL ed esegui (il tuo prefisso e la tua regione saranno probabilmente diversi).
```
curl https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/prod/
```
L'output dovrebbe essere simile al seguente:
```
Hello, AWS Solutions Constructs! You've hit /
```
Ora, rivedere gli elementi`Hits`Tabella Amazon DynamoDB.
1. Passa alla console DynamoDB.
1. Assicurarsi di essere nella regione in cui è stata creata la tabella.
1. Seleziona**Tabelle**nel riquadro di navigazione e selezionare la casella di controllo**Hits (occorrenze)**INTO table
1. Apri la tabella e seleziona «Elementi».
1. Dovresti vedere quanti colpi hai ottenuto per ogni percorso.
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/solutions/latest/constructs/images/tutorial-part2b.png)
1. Prova a colpire un nuovo percorso e aggiorna la vista Elementi. Viene visualizzato un nuovo elemento con un`hits`Conteggio di uno.
Se questo è l'output che hai ricevuto, la tua app funziona\$1
# Casi d'uso:
Questa libreria include una raccolta di implementazioni di casi d'uso funzionali per dimostrare l'utilizzo dei modelli architettonici di costrutti. Questi possono essere utilizzati allo stesso modo dei modelli architettonici e possono essere concettualizzati come un'astrazione aggiuntiva di «livello superiore» di tali modelli. I seguenti casi d'uso sono forniti come esempi funzionali:
## Sito Web AWS statico S3
Questo modello di caso d'uso (`aws-s3-static-website`) implementa una distribuzione Amazon CloudFront, Amazon S3 bucket e una risorsa personalizzata basata su AWS Lambda per copiare il contenuto del sito Web statico per il sito web demo Wild Rydes (parte del`aws-serverless-web-app`Implementazione di)
**Codice sorgente (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)
## Gestore di immagini senza server semplice AWS
Questo modello di caso d'uso (`aws-serverless-image-handler`) implementa una distribuzione Amazon CloudFront, un'API REST Gateway API di Amazon, una funzione AWS Lambda e le autorizzazioni e la logica necessarie per il provisioning di un'API funzionale del gestore di immagini per la pubblicazione del contenuto dell'immagine da uno o più bucket Amazon S3 all'interno dell'account di distribuzione.
**Codice sorgente (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)
## App Web senza server AWS
Questo modello di caso d'uso (`aws-serverless-web-app`) implementa una semplice applicazione web senza server che consente agli utenti di richiedere corse unicorno dalla flotta Wild Rydes. L'applicazione presenterà agli utenti un'interfaccia utente basata su HTML per indicare la posizione in cui vorrebbero essere prelevati e si interfaccia sul back-end con un servizio web RESTful per inviare la richiesta e inviare un unicorno vicino. L'applicazione fornirà anche servizi per gli utenti di registrarsi con il servizio e accedere prima di richiedere corse.
**Codice sorgente (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)