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à. # Tutorial: Implementa un'applicazione Hello World con AWS SAM In questo tutorial, si utilizza l'interfaccia a riga di AWS Serverless Application Model comando (AWS SAMCLI) per completare quanto segue: + Inizializza, crea e distribuisci un'applicazione **Hello World** di esempio. + Apporta modifiche locali e sincronizza con. AWS CloudFormation + Esegui test locali sul tuo host di sviluppo. + Eliminare l'applicazione di esempio da Cloud AWS. L'applicazione **Hello World** di esempio implementa un backend API di base. Consiste delle seguenti risorse: + **Amazon API Gateway**: endpoint API che utilizzerai per richiamare la tua funzione. + **AWS Lambda**— Funzione che elabora la richiesta HTTP API GET e restituisce un `hello world` messaggio. + **AWS Identity and Access Management Ruolo (IAM)**: fornisce le autorizzazioni per consentire ai servizi di interagire in modo sicuro. Il diagramma seguente mostra i componenti di questa applicazione: ![\[Un diagramma di una funzione Lambda che viene richiamata quando invii una richiesta GET all'endpoint API Gateway.\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/gs-01.png) **Topics** + [ ## Prerequisiti ](#serverless-getting-started-hello-world-prerequisites) + [ ## Passaggio 1: inizializza l'applicazione Hello World di esempio ](#serverless-getting-started-hello-world-init) + [ ## Fase 2: Crea la tua applicazione ](#serverless-getting-started-hello-world-build) + [ ## Passo 3: Distribuisci la tua applicazione su Cloud AWS ](#serverless-getting-started-hello-world-deploy) + [ ## Passaggio 4: Esegui l'applicazione ](#serverless-getting-started-hello-world-run) + [ ## Fase 5: Interagite con la vostra funzione nel Cloud AWS ](#serverless-getting-started-hello-world-remote-invoke) + [ ## Fase 6: Modificare e sincronizzare l'applicazione con Cloud AWS ](#serverless-getting-started-hello-world-sync) + [ ## Passaggio 7: (Facoltativo) Testa l'applicazione localmente ](#serverless-getting-started-hello-world-test) + [ ## Fase 8: Eliminare l'applicazione dal Cloud AWS ](#serverless-getting-started-hello-world-delete) + [ ## Risoluzione dei problemi ](#serverless-getting-started-hello-world-troubleshoot) + [ ## Ulteriori informazioni ](#serverless-getting-started-hello-world-learn) ## Prerequisiti Verifica di aver completato quanto segue: + [AWS SAM prerequisiti](prerequisites.md) + [Installa il AWS SAMCLI](install-sam-cli.md) **Nota** Se preferisci usare Visual Studio Code per lo sviluppo serverless, consulta [Creazione di applicazioni serverless](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/sam-get-started.html#serverless-apps-create) nella AWS Toolkit for VS Code User Guide step-by-step per istruzioni sull'uso dell'interfaccia VS Code. ## Passaggio 1: inizializza l'applicazione Hello World di esempio In questo passaggio, utilizzerai il AWS SAMCLI per creare un esempio di progetto applicativo **Hello World** sul tuo computer locale. **Per inizializzare l'applicazione Hello World di esempio** 1. Nella riga di comando, esegui quanto segue da una directory iniziale a tua scelta: ``` $ sam init ``` **Nota** Questo comando inizializza l'applicazione serverless e crea una directory di progetto. La directory contiene diversi file e cartelle, incluso il `template.yaml` file, che è il modello. AWS SAM La versione di Python installata deve corrispondere alla `Runtime` proprietà specificata in. `template.yaml` Per i carichi di lavoro di produzione, consigliamo di utilizzare Python 3.12 o versioni precedenti completamente supportate negli ambienti. AWS Se le versioni di Python non corrispondono, si verificheranno errori di compilazione. Per risolvere i problemi di compatibilità delle versioni: Specificate un [runtime](sam-cli-command-reference-sam-init.md#sam-cli-command-reference-sam-init-options-runtime) compatibile durante l'inizializzazione: `sam init --runtime python3.9` Modifica la `Runtime` proprietà `template.yaml` dopo l'inizializzazione 1. Ti AWS SAMCLI guiderà attraverso l'inizializzazione di una nuova applicazione. Configura quanto segue: 1. Seleziona **Modelli di avvio AWS rapido** per scegliere un modello iniziale. 1. Scegli il modello **Hello World Example** e scaricalo. 1. Usa il Python runtime e il tipo di `zip` pacchetto. 1. Per questo tutorial, disattiva il AWS X-Ray tracciamento. Per saperne di più, vedi [Cos'è AWS X-Ray?](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) nella *Guida per gli AWS X-Ray sviluppatori*. 1. Per questo tutorial, disattiva il monitoraggio con Amazon CloudWatch Application Insights. Per ulteriori informazioni, consulta [Amazon CloudWatch Application Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html) nella *Amazon CloudWatch User Guide*. 1. Per questo tutorial, disattiva l'impostazione della registrazione strutturata in formato JSON sulle tue funzioni Lambda. 1. **Assegna un nome alla tua applicazione come sam-app.** Per utilizzare il flusso AWS SAMCLI interattivo: + Le parentesi (`[ ]`) indicano i valori predefiniti. Lascia vuota la risposta per selezionare il valore predefinito. + Inserisci **`y`** per **sì** e **`n`** per **no**. Di seguito è riportato un esempio di flusso `sam init` interattivo: ``` $ sam init ... Which template source would you like to use? 1 - AWS Quick Start Templates 2 - Custom Template Location Choice: 1 Choose an AWS Quick Start application template 1 - Hello World Example 2 - Data processing 3 - Hello World Example with Powertools for AWS Lambda 4 - Multi-step workflow 5 - Scheduled task 6 - Standalone function 7 - Serverless API 8 - Infrastructure event management 9 - Lambda Response Streaming 10 - GraphQLApi Hello World Example 11 - Full Stack 12 - Lambda EFS example 13 - Serverless Connector Hello World Example 14 - Multi-step workflow with Connectors 15 - DynamoDB Example 16 - Machine Learning Template: 1 Use the most popular runtime and package type? (Python and zip) [y/N]: y Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER Would you like to enable monitoring using CloudWatch Application Insights? For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER Would you like to set Structured Logging in JSON format on your Lambda functions? [y/N]: ENTER Project name [sam-app]: ENTER ``` 1. AWS SAMCLIScarica il modello iniziale e crea la struttura di directory del progetto applicativo sul computer locale. Di seguito è riportato un esempio dell' AWS SAMCLIoutput: ``` Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment) ----------------------- Generating application: ----------------------- Name: sam-app Runtime: python3.9 Architectures: x86_64 Dependency Manager: pip Application Template: hello-world Output Directory: . Configuration file: sam-app/samconfig.toml Next steps can be found in the README file at sam-app/README.md Commands you can use next ========================= [*] Create pipeline: cd sam-app && sam pipeline init --bootstrap [*] Validate SAM template: cd sam-app && sam validate [*] Test Function in the Cloud: cd sam-app && sam sync --stack-name {stack-name} --watch ``` 1. Dalla riga di comando, spostatevi nella `sam-app` directory appena creata. Di seguito è riportato un esempio di ciò che AWS SAMCLI ha creato: **Nota** Se `tree` il comando non è installato automaticamente, esegui questo comando: `brew install tree` ``` $ cd sam-app $ tree ├── README.md ├── __init__.py ├── events │ └── event.json ├── hello_world │ ├── __init__.py │ ├── app.py │ └── requirements.txt ├── samconfig.toml ├── template.yaml └── tests ├── __init__.py ├── integration │ ├── __init__.py │ └── test_api_gateway.py ├── requirements.txt └── unit ├── __init__.py └── test_handler.py 6 directories, 14 files ``` Alcuni file importanti da evidenziare: + `hello_world/app.py`— Contiene il codice della funzione Lambda. + `hello_world/requirements.txt`— Contiene tutte Python le dipendenze richieste dalla funzione Lambda. + `samconfig.toml`— File di configurazione per l'applicazione che memorizza i parametri predefiniti utilizzati da. AWS SAMCLI + `template.yaml`— Il AWS SAM modello che contiene il codice dell'infrastruttura dell'applicazione. Ora hai un'applicazione serverless completamente creata sul tuo computer locale\$1 ## Fase 2: Crea la tua applicazione In questo passaggio, si utilizza il AWS SAMCLI per creare l'applicazione e prepararla per la distribuzione. Quando compili, AWS SAMCLI crea una `.aws-sam` directory e vi organizza le dipendenze delle funzioni, il codice del progetto e i file di progetto. **Per creare la tua applicazione** + Nella riga di comando, dalla directory del `sam-app` progetto, esegui quanto segue: ``` $ sam build ``` **Nota** Se non lo hai Python sul tuo computer locale, usa invece il **sam build --use-container ** comando. AWS SAMCLICreerà un Docker contenitore che include il runtime e le dipendenze della funzione. Questo comando richiede la Docker presenza sul computer locale. Per l'installazioneDocker, vedere[Installazione di Docker](install-docker.md). Di seguito è riportato un esempio dell' AWS SAMCLIoutput: ``` $ sam build Starting Build use cache Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source Building codeuri: /Users/.../Demo/sam-tutorial1/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction Running PythonPipBuilder:CleanUp Running PythonPipBuilder:ResolveDependencies Running PythonPipBuilder:CopySource Running PythonPipBuilder:CopySource Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml Commands you can use next ========================= [*] Validate SAM template: sam validate [*] Invoke Function: sam local invoke [*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch [*] Deploy: sam deploy --guided ``` Di seguito è riportato un esempio abbreviato della `.aws-sam` directory creata dalla AWS SAM CLI: ``` .aws-sam ├── build │ ├── HelloWorldFunction │ │ ├── __init__.py │ │ ├── app.py │ │ └── requirements.txt │ └── template.yaml └── build.toml ``` Alcuni file importanti da evidenziare: + `build/HelloWorldFunction`— Contiene il codice della funzione Lambda e le dipendenze. AWS SAMCLICrea una directory per ogni funzione dell'applicazione. + `build/template.yaml`— Contiene una copia del AWS SAM modello a cui fa riferimento CloudFormation durante la distribuzione. + `build.toml`— File di configurazione che memorizza i valori dei parametri predefiniti a cui fa riferimento AWS SAMCLI durante la creazione e la distribuzione dell'applicazione. Ora sei pronto per distribuire la tua applicazione su. Cloud AWS ## Passo 3: Distribuisci la tua applicazione su Cloud AWS **Nota** Questo passaggio richiede la configurazione AWS delle credenziali. Per ulteriori informazioni, consulta [Passaggio 5: Utilizzare AWS CLI per configurare le AWS credenziali](prerequisites.md#prerequisites-configure-credentials) in [AWS SAM prerequisiti](prerequisites.md). In questo passaggio, si utilizza AWS SAMCLI per distribuire l'applicazione su. Cloud AWS AWS SAMCLIFaranno quanto segue: + Guida l'utente nella configurazione delle impostazioni dell'applicazione per la distribuzione. + Carica i file dell'applicazione su Amazon Simple Storage Service (Amazon S3). + Trasforma il tuo AWS SAM modello in un CloudFormation modello. Quindi carica il modello sul CloudFormation servizio per fornire AWS le tue risorse. **Per distribuire l'applicazione su** 1. Nella riga di comando, dalla directory del `sam-app` progetto, esegui quanto segue: ``` $ sam deploy --guided ``` 1. Segui il flusso AWS SAMCLI interattivo per configurare le impostazioni dell'applicazione. Configura quanto segue: 1. Il **nome CloudFormation dello stack**: uno stack è una raccolta di AWS risorse che puoi gestire come singola unità. *Per ulteriori informazioni, consulta [Lavorare con gli stack nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html) per l'AWS CloudFormation utente.* 1. Il **Regione AWS**su cui distribuire lo CloudFormation stack. Per ulteriori informazioni, consulta [Endpoint CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-endpoints.html) nella *Guida per l'utente di AWS CloudFormation *. 1. Per questo tutorial, disattiva la **conferma delle modifiche prima della distribuzione**. 1. Consenti **la creazione di ruoli IAM**: consente di AWS SAM creare il ruolo IAM necessario per l'interazione tra la risorsa API Gateway e la risorsa della funzione Lambda. 1. Per questo tutorial, disattiva la **disabilitazione del rollback**. 1. Consenti **HelloWorldFunction senza autorizzazione definita**: questo messaggio viene visualizzato perché l'endpoint API Gateway è configurato per essere accessibile pubblicamente, senza autorizzazione. Poiché questa è la configurazione prevista per l'applicazione Hello World, consenti AWS SAMCLI di continuare. Per ulteriori informazioni sulla configurazione dell'autorizzazione, consulta[Controlla l'accesso alle API con il tuo AWS SAM modello](serverless-controlling-access-to-apis.md). 1. **Salva gli argomenti nel file di configurazione**: questo aggiornerà il `samconfig.toml` file dell'applicazione con le preferenze di distribuzione. 1. Seleziona il **nome del file di configurazione** predefinito. 1. Seleziona l'**ambiente di configurazione** predefinito. Di seguito è riportato un esempio di output del flusso `sam deploy --guided` interattivo: ``` $ sam deploy --guided Configuring SAM deploy ====================== Looking for config file [samconfig.toml] : Found Reading default arguments : Success Setting default arguments for 'sam deploy' ========================================= Stack Name [sam-app]: ENTER AWS Region [us-west-2]: ENTER #Shows you resources changes to be deployed and require a 'Y' to initiate deploy Confirm changes before deploy [Y/n]: n #SAM needs permission to be able to create roles to connect to the resources in your template Allow SAM CLI IAM role creation [Y/n]: ENTER #Preserves the state of previously provisioned resources when an operation fails Disable rollback [y/N]: ENTER HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y Save arguments to configuration file [Y/n]: ENTER SAM configuration file [samconfig.toml]: ENTER SAM configuration environment [default]: ENTER ``` 1. AWS SAMCLIImplementa l'applicazione effettuando le seguenti operazioni: + Quindi AWS SAMCLI crea un bucket Amazon S3 e carica la tua directory. `.aws-sam` + AWS SAMCLITrasforma il AWS SAM modello in CloudFormation e lo carica sul servizio. CloudFormation + CloudFormation fornisce le tue risorse. Durante la distribuzione, AWS SAMCLI mostra i tuoi progressi. Di seguito è riportato un esempio di output: ``` Looking for resources needed for deployment: Managed S3 bucket: aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr A different default S3 bucket can be set in samconfig.toml Parameter "stack_name=sam-app" in [default.deploy.parameters] is defined as a global parameter [default.global.parameters]. This parameter will be only saved under [default.global.parameters] in /Users/.../Demo/sam-tutorial1/sam-app/samconfig.toml. Saved arguments to config file Running 'sam deploy' for future deployments will use the parameters saved above. The above parameters can be changed by modifying samconfig.toml Learn more about samconfig.toml syntax at https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html File with same data already exists at sam-app/da3c598813f1c2151579b73ad788cac8, skipping upload Deploying with following values =============================== Stack name : sam-app Region : us-west-2 Confirm changeset : False Disable rollback : False Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr Capabilities : ["CAPABILITY_IAM"] Parameter overrides : {} Signing Profiles : {} Initiating deployment ===================== File with same data already exists at sam-app/2bebf67c79f6a743cc5312f6dfc1efee.template, skipping upload Waiting for changeset to be created.. CloudFormation stack changeset --------------------------------------------------------------------------------------------------------------------------------------------- Operation LogicalResourceId ResourceType Replacement --------------------------------------------------------------------------------------------------------------------------------------------- * Modify HelloWorldFunction AWS::Lambda::Function False * Modify ServerlessRestApi AWS::ApiGateway::RestApi False - Delete AwsSamAutoDependencyLayerNestedSt AWS::CloudFormation::Stack N/A ack --------------------------------------------------------------------------------------------------------------------------------------------- Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1678917603/22e05525-08f9-4c52-a2c4-f7f1fd055072 2023-03-15 12:00:16 - Waiting for stack create/update to complete CloudFormation events from stack operations (refresh every 0.5 seconds) --------------------------------------------------------------------------------------------------------------------------------------------- ResourceStatus ResourceType LogicalResourceId ResourceStatusReason --------------------------------------------------------------------------------------------------------------------------------------------- UPDATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction - UPDATE_COMPLETE AWS::Lambda::Function HelloWorldFunction - UPDATE_COMPLETE_CLEANUP_IN_PROGRE AWS::CloudFormation::Stack sam-app - SS DELETE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt - ack DELETE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt - ack UPDATE_COMPLETE AWS::CloudFormation::Stack sam-app - --------------------------------------------------------------------------------------------------------------------------------------------- CloudFormation outputs from deployed stack ---------------------------------------------------------------------------------------------------------------------------------------------- Outputs ---------------------------------------------------------------------------------------------------------------------------------------------- Key HelloWorldFunctionIamRole Description Implicit IAM Role created for Hello World function Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-15GLOUR9LMT1W Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://.execute-api.us-west-2.amazonaws.com/Prod/hello/ Key HelloWorldFunction Description Hello World Lambda Function ARN Value arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-yQDNe17r9maD ---------------------------------------------------------------------------------------------------------------------------------------------- Successfully created/updated stack - sam-app in us-west-2 ``` L'applicazione è ora distribuita e in esecuzione in\$1 Cloud AWS ## Passaggio 4: Esegui l'applicazione In questo passaggio, invierai una richiesta GET all'endpoint API e vedrai l'output della funzione Lambda. **Per ottenere il valore dell'endpoint dell'API** 1. Dalle informazioni visualizzate AWS SAMCLI nel passaggio precedente, individua la `Outputs` sezione. In questa sezione, individua la `HelloWorldApi` risorsa per trovare il valore dell'endpoint HTTP. Di seguito è riportato un esempio di output: ``` ---------------------------------------------------------------------------------------------------------------------------------------------- Outputs ---------------------------------------------------------------------------------------------------------------------------------------------- ... Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/ ... ---------------------------------------------------------------------------------------------------------------------------------------------- ``` 1. In alternativa, è possibile utilizzare il **sam list endpoints --output json** comando per ottenere queste informazioni. Di seguito è riportato un esempio di output: ``` $ sam list endpoints --output json 2023-03-15 12:39:19 Loading policies from IAM... 2023-03-15 12:39:25 Finished loading policies from IAM. [ { "LogicalResourceId": "HelloWorldFunction", "PhysicalResourceId": "sam-app-HelloWorldFunction-yQDNe17r9maD", "CloudEndpoint": "-", "Methods": "-" }, { "LogicalResourceId": "ServerlessRestApi", "PhysicalResourceId": "ets1gv8lxi", "CloudEndpoint": [ "https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod", "https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Stage" ], "Methods": [ "/hello['get']" ] } ] ``` **Per richiamare la tua funzione** + Utilizzando il browser o la riga di comando, invia una richiesta GET all'endpoint API. Di seguito è riportato un esempio di utilizzo del comando curl: ``` $ curl https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/ {"message": "hello world"} ``` ## Fase 5: Interagite con la vostra funzione nel Cloud AWS In questo passaggio, si utilizza AWS SAMCLI per richiamare la funzione Lambda in. Cloud AWS **Per richiamare la funzione Lambda nel cloud** 1. Prendi nota delle tue funzioni del `LogicalResourceId` passaggio precedente. Dovrebbe essere `HelloWorldFunction`. 1. Nella riga di comando, dalla directory del `sam-app` progetto, esegui quanto segue: ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app ``` 1. AWS SAMCLIrichiama la tua funzione nel cloud e restituisce una risposta. Di seguito è riportato un esempio di output: ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app Invoking Lambda Function HelloWorldFunction START RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 Version: $LATEST END RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 REPORT RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 Duration: 6.62 ms Billed Duration: 7 ms Memory Size: 128 MB Max Memory Used: 67 MB Init Duration: 164.06 ms {"statusCode":200,"body":"{\"message\":\"hello world\"}"}% ``` ## Fase 6: Modificare e sincronizzare l'applicazione con Cloud AWS In questo passaggio, si utilizza il AWS SAMCLI **sam sync --watch** comando per sincronizzare le modifiche locali a Cloud AWS. **Per usare sam sync** 1. Nella riga di comando, dalla directory del `sam-app` progetto, esegui quanto segue: ``` $ sam sync --watch ``` 1. Ti AWS SAMCLI chiede di confermare che stai sincronizzando uno stack di sviluppo. Poiché il **sam sync --watch** comando distribuisce automaticamente le modifiche locali Cloud AWS in tempo reale, lo consigliamo solo per gli ambienti di sviluppo. AWS SAMCLIEsegue una distribuzione iniziale prima di iniziare il monitoraggio delle modifiche locali. Di seguito è riportato un esempio di output: ``` $ sam sync --watch The SAM CLI will use the AWS Lambda, Amazon API Gateway, and AWS StepFunctions APIs to upload your code without performing a CloudFormation deployment. This will cause drift in your CloudFormation stack. **The sync command should only be used against a development stack**. Confirm that you are synchronizing a development stack. Enter Y to proceed with the command, or enter N to cancel: [Y/n]: y Queued infra sync. Waiting for in progress code syncs to complete... Starting infra sync. Manifest is not changed for (HelloWorldFunction), running incremental build Building codeuri: /Users/.../Demo/sam-tutorial1/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction Running PythonPipBuilder:CopySource Build Succeeded Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpq3x9vh63. Execute the following command to deploy the packaged template sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpq3x9vh63 --stack-name Deploying with following values =============================== Stack name : sam-app Region : us-west-2 Disable rollback : False Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr Capabilities : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"] Parameter overrides : {} Signing Profiles : null Initiating deployment ===================== 2023-03-15 13:10:05 - Waiting for stack create/update to complete CloudFormation events from stack operations (refresh every 0.5 seconds) --------------------------------------------------------------------------------------------------------------------------------------------- ResourceStatus ResourceType LogicalResourceId ResourceStatusReason --------------------------------------------------------------------------------------------------------------------------------------------- UPDATE_IN_PROGRESS AWS::CloudFormation::Stack sam-app Transformation succeeded CREATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt - ack CREATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt Resource creation Initiated ack CREATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt - ack UPDATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction - UPDATE_COMPLETE AWS::Lambda::Function HelloWorldFunction - UPDATE_COMPLETE_CLEANUP_IN_PROGRE AWS::CloudFormation::Stack sam-app - SS UPDATE_COMPLETE AWS::CloudFormation::Stack sam-app - --------------------------------------------------------------------------------------------------------------------------------------------- CloudFormation outputs from deployed stack ---------------------------------------------------------------------------------------------------------------------------------------------- Outputs ---------------------------------------------------------------------------------------------------------------------------------------------- Key HelloWorldFunctionIamRole Description Implicit IAM Role created for Hello World function Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-15GLOUR9LMT1W Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/ Key HelloWorldFunction Description Hello World Lambda Function ARN Value arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-yQDNe17r9maD ---------------------------------------------------------------------------------------------------------------------------------------------- Stack update succeeded. Sync infra completed. Infra sync completed. CodeTrigger not created as CodeUri or DefinitionUri is missing for ServerlessRestApi. ``` Successivamente, modificherai il codice della funzione Lambda. AWS SAMCLIRileverà automaticamente questa modifica e sincronizzerà l'applicazione con. Cloud AWS **Per modificare e sincronizzare l'applicazione** 1. Apri il `sam-app/hello_world/app.py` file nel tuo IDE preferito. 1. Modifica `message` e salva il file. Di seguito è riportato un esempio: ``` import json ... def lambda_handler(event, context): ... return { "statusCode": 200, "body": json.dumps({ "message": "hello everyone!", ... }), } ``` 1. AWS SAMCLIRileva la modifica e sincronizza l'applicazione con. Cloud AWS Di seguito è riportato un esempio di output: ``` Syncing Lambda Function HelloWorldFunction... Manifest is not changed for (HelloWorldFunction), running incremental build Building codeuri: /Users/.../Demo/sam-tutorial1/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction Running PythonPipBuilder:CopySource Finished syncing Lambda Function HelloWorldFunction. ``` 1. Per verificare la modifica, invia nuovamente una richiesta GET all'endpoint API. ``` $ curl https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/ {"message": "hello everyone!"} ``` ## Passaggio 7: (Facoltativo) Testa l'applicazione localmente **Nota** Questa fase è facoltativa. **Importante** Questo passaggio richiede un Docker computer locale. È necessario averlo Docker installato e configurato per utilizzarlo AWS SAMCLI per i test locali. Per ulteriori informazioni, consulta [Installazione di Docker](install-docker.md). In questo passaggio, si utilizza il AWS SAMCLI **sam local** comando per testare l'applicazione localmente. A tale scopo, AWS SAMCLI crea un ambiente locale utilizzandoDocker. Questo ambiente locale emula l'ambiente di esecuzione basato sul cloud della funzione Lambda. Si eseguiranno le operazioni indicate di seguito. 1. Crea un ambiente locale per la tua funzione Lambda e invocala. 1. Ospita l'endpoint dell'API HTTP localmente e usalo per richiamare la funzione Lambda. **Per richiamare la funzione Lambda localmente** 1. Nella riga di comando, dalla directory del `sam-app` progetto, esegui quanto segue: ``` $ sam local invoke ``` 1. AWS SAMCLICrea un Docker contenitore locale e richiama la tua funzione. Di seguito è riportato un esempio di output: ``` $ sam local invoke Invoking app.lambda_handler (python3.9) Local image was not found. Removing rapid images for repo public.ecr.aws/sam/emulation-python3.9 Building image..................... Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../Demo/sam-tutorial1/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container START RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6 Version: $LATEST END RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6 REPORT RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6 Init Duration: 1.01 ms Duration: 633.45 ms Billed Duration: 634 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode": 200, "body": "{\"message\": \"hello world\"}"} ``` **Per ospitare la tua API localmente** 1. Nella riga di comando, dalla directory del `sam-app` progetto, esegui quanto segue: ``` $ sam local start-api ``` 1. AWS SAMCLICrea un Docker contenitore locale per la tua funzione Lambda e crea un server HTTP locale per simulare l'endpoint dell'API. Di seguito è riportato un esempio di output: ``` $ sam local start-api Initializing the lambda functions containers. Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../Demo/sam-tutorial1/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container Containers Initialization is done. Mounting HelloWorldFunction at http://127.0.0.1:3000/hello [GET] You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart AWS SAM CLI if you update your AWS SAM template 2023-03-15 14:25:21 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3000 2023-03-15 14:25:21 Press CTRL+C to quit ``` 1. Utilizzando il browser o la riga di comando, inviate una richiesta GET all'endpoint API locale. Di seguito è riportato un esempio di utilizzo del comando curl: ``` $ curl http://127.0.0.1:3000/hello {"message": "hello world"} ``` ## Fase 8: Eliminare l'applicazione dal Cloud AWS In questo passaggio, si utilizza il AWS SAMCLI **sam delete** comando per eliminare l'applicazione da Cloud AWS. **Per eliminare l'applicazione da Cloud AWS** 1. Nella riga di comando, dalla directory del `sam-app` progetto, esegui quanto segue: ``` $ sam delete ``` 1. Ti AWS SAMCLI chiederà di confermare. Quindi, eliminerà il bucket e lo stack Amazon S3 dell'applicazione. CloudFormation Di seguito è riportato un esempio di output: ``` $ sam delete Are you sure you want to delete the stack sam-app in the region us-west-2 ? [y/N]: y Are you sure you want to delete the folder sam-app in S3 which contains the artifacts? [y/N]: y - Deleting S3 object with key c6ce8fa8b5a97dd022ecd006536eb5a4 - Deleting S3 object with key 5d513a459d062d644f3b7dd0c8b56a2a.template - Deleting S3 object with key sam-app/2bebf67c79f6a743cc5312f6dfc1efee.template - Deleting S3 object with key sam-app/6b208d0e42ad15d1cee77d967834784b.template - Deleting S3 object with key sam-app/da3c598813f1c2151579b73ad788cac8 - Deleting S3 object with key sam-app/f798cdd93cee188a71d120f14a035b11 - Deleting Cloudformation stack sam-app Deleted successfully ``` ## Risoluzione dei problemi Per risolvere il problema AWS SAMCLI, vedere. [AWS SAMCLIrisoluzione dei problemi](sam-cli-troubleshooting.md) ## Ulteriori informazioni Per continuare a saperne di più AWS SAM, consulta le seguenti risorse: + **[Il AWS SAM workshop completo](https://s12d.com/sam-ws-en-intro)**: un workshop progettato per insegnarti molte delle principali funzionalità che AWS SAM offre. + **[Sessioni con SAM](https://www.youtube.com/playlist?list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd)** — Serie di video creata dal nostro team di AWS Serverless Developer Advocate sull'utilizzo. AWS SAM + **[Serverless Land](https://serverlessland.com/)**: sito che riunisce le informazioni, i blog, i video, il codice e le risorse di apprendimento più recenti per la tecnologia serverless. AWS