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à. # AWS SAMCLITerraformsupporto Questa sezione descrive l'utilizzo dell'interfaccia a riga di AWS Serverless Application Model comando (AWS SAMCLI) con i tuoi Terraform progetti e Terraform Cloud. Per fornire feedback e inviare richieste di funzionalità, crea un [GitHubproblema](https://github.com/aws/aws-sam-cli/issues/new?labels=area%2Fterraform). **Topics** + [Guida introduttiva Terraform al supporto per AWS SAMCLI](gs-terraform-support.md) + [Utilizzo di AWS SAMCLI with Terraform per il debug e il test locali](using-samcli-terraform.md) + [Utilizzo di AWS SAMCLI with Serverless.tf per il debug e il test locali](using-samcli-serverlesstf.md) + [AWS SAMCLIcon riferimento Terraform](terraform-reference.md) + [A cosa serve AWS SAMCLI il supportoTerraform?](#what-is-terraform-support) # Guida introduttiva Terraform al supporto per AWS SAMCLI Questo argomento spiega come iniziare a utilizzare l'interfaccia a riga di AWS Serverless Application Model comando (AWS SAMCLI) conTerraform. Per fornire feedback e inviare richieste di funzionalità, crea un [GitHubproblema](https://github.com/aws/aws-sam-cli/issues/new?labels=area%2Fterraform). **Topics** + [AWS SAMCLITerraformprerequisiti](#gs-terraform-support-prerequisites) + [Utilizzo dei AWS SAMCLI comandi con Terraform](#gs-terraform-support-using) + [Configurazione per Terraform progetti](#gs-terraform-support-projects) + [Configurazione di Terraform Cloud](#gs-terraform-support-cloud) ## AWS SAMCLITerraformprerequisiti Completa tutti i prerequisiti per iniziare a utilizzarlo AWS SAMCLI con i tuoi Terraform progetti. 1. **Installa o aggiorna il AWS SAMCLI** Per verificare se è AWS SAMCLI installato, esegui quanto segue: ``` $ sam --version ``` Se AWS SAMCLI è già installato, l'output mostrerà una versione. Per eseguire l'aggiornamento alla versione più recente, vedere[Aggiornamento del AWS SAMCLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade). Per istruzioni sull'installazione di AWS SAMCLI e tutti i relativi prerequisiti, vedere. [Installa il AWS SAMCLI](install-sam-cli.md) 1. **Installazione di Terraform** Per verificare se l'Terraforminstallazione è stata eseguita, esegui quanto segue: ``` $ terraform -version ``` Per l'installazioneTerraform, consulta [Installa Terraform](https://developer.hashicorp.com/terraform/downloads) nel *Terraformregistro*. 1. **Installa Docker per il test locale** I AWS SAMCLI requisiti Docker per i test locali. Per l'installazioneDocker, vedere[Installazione di Docker da utilizzare con AWS SAMCLI](install-docker.md). ## Utilizzo dei AWS SAMCLI comandi con Terraform Quando esegui un AWS SAMCLI comando supportato, usa l'`--hook-name`opzione e fornisci il `terraform` valore. Di seguito è riportato un esempio: ``` $ sam local invoke --hook-name terraform ``` Puoi configurare questa opzione nel tuo file AWS SAMCLI di configurazione con quanto segue: ``` hook_name = "terraform" ``` ## Configurazione per Terraform progetti Completa i passaggi descritti in questo argomento per utilizzarlo AWS SAMCLI con i Terraform progetti. Non è richiesta alcuna configurazione aggiuntiva se costruite gli AWS Lambda artefatti all'esterno del Terraform progetto. Vedi [Utilizzo di AWS SAMCLI with Terraform per il debug e il test locali](using-samcli-terraform.md) per iniziare a usare. AWS SAMCLI Se costruisci i tuoi artefatti Lambda all'interno Terraform dei tuoi progetti, devi fare quanto segue: 1. Installa 3.8 Python o versione successiva 1. Installa lo strumento. Make 1. Definisci la logica di costruzione degli artefatti Lambda all'interno del tuo progetto. Terraform 1. Definisci una `sam metadata` risorsa per informarli sulla tua logica AWS SAMCLI di compilazione. 1. Usa il AWS SAMCLI `sam build` comando per creare i tuoi artefatti Lambda. ### Installa 3.8 Python o versione successiva Python3.8 o versione successiva è richiesta per l'utilizzo con. AWS SAMCLI Quando esegui`sam build`, le AWS SAMCLI creazioni `makefiles` che contengono Python comandi per creare i tuoi artefatti Lambda. *Per istruzioni di installazione, consulta [Downloading Python in Python's](https://wiki.python.org/moin/BeginnersGuide/Download) Beginners Guide.* Verifica che Python 3.8 o versione successiva sia aggiunto al percorso del tuo computer eseguendo: ``` $ python --version ``` L'output dovrebbe mostrare una versione di Python 3.8 o successiva. ### Installa lo strumento Make GNU[Make](https://www.gnu.org/software/make/)è uno strumento che controlla la generazione di eseguibili e altri file non sorgente per il progetto. Le AWS SAMCLI creazioni `makefiles` che si affidano a questo strumento per creare i tuoi artefatti Lambda. Se non lo avete Make installato sul computer locale, installatelo prima di procedere. Per Windows, puoi installarlo usando [Chocolatey](https://chocolatey.org/). Per istruzioni, vedi [Uso di Chocolatey](https://www.technewstoday.com/install-and-use-make-in-windows/#using-chocolatey) in *Come installare e usare «Make*» in Windows ### Definisci la logica di compilazione degli artefatti Lambda Usa il tipo di `null_resource` Terraform risorsa per definire la logica di compilazione Lambda. Di seguito è riportato un esempio che utilizza uno script di compilazione personalizzato per creare una funzione Lambda. ``` resource "null_resource" "build_lambda_function" { triggers = { build_number = "${timestamp()}" } provisioner "local-exec" { command = substr(pathexpand("~"), 0, 1) == "/"? "./py_build.sh \"${local.lambda_src_path}\" \"${local.building_path}\" \"${local.lambda_code_filename}\" Function" : "powershell.exe -File .\\PyBuild.ps1 ${local.lambda_src_path} ${local.building_path} ${local.lambda_code_filename} Function" } } ``` ### Definire una risorsa sam metadata La `sam metadata` risorsa è un tipo di `null_resource` Terraform risorsa che fornisce AWS SAMCLI le informazioni necessarie per localizzare gli artefatti Lambda. È necessaria una `sam metadata` risorsa unica per ogni funzione o layer Lambda del progetto. *Per ulteriori informazioni su questo tipo di risorsa, consulta [null\$1resource](https://registry.terraform.io/providers/hashicorp/null/latest/docs/resources/resource) nel registro. Terraform* **Per definire una risorsa sam metadata** 1. Assegna un nome `sam_metadata_` alla risorsa iniziando con per identificare la risorsa come sam metadata risorsa. 1. Definisci le proprietà degli artefatti Lambda all'interno del `triggers` blocco della risorsa. 1. Specificate il `null_resource` che contiene la logica di compilazione Lambda con l'`depends_on`argomento. Di seguito è riportato un modello di esempio: ``` resource "null_resource" "sam_metadata_..." { triggers = { resource_name = resource_name resource_type = resource_type original_source_code = original_source_code built_output_path = built_output_path } depends_on = [ null_resource.build_lambda_function # ref to your build logic ] } ``` Di seguito è riportato un esempio di `sam metadata` risorsa: ``` resource "null_resource" "sam_metadata_aws_lambda_function_publish_book_review" { triggers = { resource_name = "aws_lambda_function.publish_book_review" resource_type = "ZIP_LAMBDA_FUNCTION" original_source_code = "${local.lambda_src_path}" built_output_path = "${local.building_path}/${local.lambda_code_filename}" } depends_on = [ null_resource.build_lambda_function ] } ``` Il contenuto della `sam metadata` risorsa varierà in base al tipo di risorsa Lambda (funzione o layer) e al tipo di pacchetto (ZIP o immagine). Per ulteriori informazioni, oltre ad esempi, vedere[risorsa di metadati sam](terraform-sam-metadata.md). Quando configuri una `sam metadata` risorsa e utilizzi un AWS SAMCLI comando supportato, AWS SAMCLI genererà il file di metadati prima di eseguire il AWS SAMCLI comando. Dopo aver generato questo file, puoi utilizzare l'`--skip-prepare-infra`opzione con AWS SAMCLI i comandi futuri per saltare il processo di generazione dei metadati e risparmiare tempo. Questa opzione deve essere utilizzata solo se non hai apportato modifiche all'infrastruttura, come la creazione di nuove funzioni Lambda o nuovi endpoint API. ### Usa il AWS SAMCLI per costruire i tuoi artefatti Lambda Usa il AWS SAMCLI `sam build` comando per creare i tuoi artefatti Lambda. Quando esegui`sam build`, AWS SAMCLI esegue le seguenti operazioni: 1. Cerca `sam metadata` risorse nel tuo Terraform progetto per conoscere e localizzare le tue risorse Lambda. 1. Avvia la logica di compilazione Lambda per creare gli artefatti Lambda. 1. Crea una `.aws-sam` directory che organizza il Terraform progetto da utilizzare con i comandi. AWS SAMCLI `sam local` **Per creare con sam build** 1. Dalla directory contenente il modulo Terraform root, esegui quanto segue: ``` $ sam build --hook-name terraform ``` 1. Per creare una funzione o un layer Lambda specifico, esegui quanto segue ``` $ sam build --hook-name terraform lambda-resource-id ``` L'ID della risorsa Lambda può essere il nome della funzione Lambda o l'indirizzo completo della Terraform risorsa, ad esempio o. `aws_lambda_function.list_books` `module.list_book_function.aws_lambda_function.this[0]` Se il codice sorgente della funzione o altri file di Terraform configurazione si trovano all'esterno della directory contenente il modulo Terraform root, è necessario specificare la posizione. Utilizzate l'`--terraform-project-root-path`opzione per specificare il percorso assoluto o relativo della directory di primo livello contenente questi file. Di seguito è riportato un esempio: ``` $ sam build --hook-name terraform --terraform-project-root-path ~/projects/terraform/demo ``` #### Crea usando un contenitore Quando si esegue il AWS SAMCLI `sam build` comando, è possibile configurarlo AWS SAMCLI per creare l'applicazione utilizzando un Docker contenitore locale. **Nota** È necessario averlo Docker installato e configurato. Per istruzioni, consulta [Installazione di Docker da utilizzare con AWS SAMCLI](install-docker.md). **Per creare utilizzando un contenitore** 1. Crea un `Dockerfile` file che contenga gli Make strumenti TerraformPython, e. Dovresti includere anche il runtime della funzione Lambda. Di seguito è riportato un esempio`Dockerfile`: ``` FROM public.ecr.aws/amazonlinux/amazonlinux:2 RUN yum -y update \ && yum install -y unzip tar gzip bzip2-devel ed gcc gcc-c++ gcc-gfortran \ less libcurl-devel openssl openssl-devel readline-devel xz-devel \ zlib-devel glibc-static libcxx libcxx-devel llvm-toolset-7 zlib-static \ && rm -rf /var/cache/yum RUN yum -y install make \ && yum -y install zip RUN yum install -y yum-utils \ && yum-config-manager --add-repo https://rpm.releases.hashicorp.com/AmazonLinux/hashicorp.repo \ && yum -y install terraform \ && terraform --version # AWS Lambda Builders RUN amazon-linux-extras enable python3.8 RUN yum clean metadata && yum -y install python3.8 RUN curl -L get-pip.io | python3.8 RUN pip3 install aws-lambda-builders RUN ln -s /usr/bin/python3.8 /usr/bin/python3 RUN python3 --version VOLUME /project WORKDIR /project ENTRYPOINT ["sh"] ``` 1. [https://docs.docker.com/engine/reference/commandline/build/](https://docs.docker.com/engine/reference/commandline/build/)Usalo per creare la tua Docker immagine. Di seguito è riportato un esempio: ``` $ docker build --tag terraform-build:v1 ``` 1. Esegui il AWS SAMCLI `sam build` comando con le `--build-image` opzioni `--use-container` and. Di seguito è riportato un esempio: ``` $ sam build --use-container --build-image terraform-build:v1 ``` ### Fasi successive Per iniziare a utilizzarlo AWS SAMCLI con i tuoi Terraform progetti, consulta[Utilizzo di AWS SAMCLI with Terraform per il debug e il test locali](using-samcli-terraform.md). ## Configurazione di Terraform Cloud Ti consigliamo di utilizzare Terraform v1.6.0 una versione più recente. Se si utilizza una versione precedente, è necessario generare un file del Terraform piano localmente. Il file del piano locale fornisce AWS SAM CLI le informazioni necessarie per eseguire test e debug locali. **Per generare un file di piano locale** **Nota** Questi passaggi non sono necessari Terraform v1.6.0 o più recenti. Per iniziare a usare AWS SAM CLI withTerraform Cloud, consulta[ AWS SAMCLIUsando con Terraform](using-samcli-terraform.md). 1. **Configura un token API**: il tipo di token dipenderà dal tuo livello di accesso. Per ulteriori informazioni, consulta [API Tokens](https://developer.hashicorp.com/terraform/cloud-docs/users-teams-organizations/api-tokens) nella *Terraform Clouddocumentazione*. 1. **Imposta la variabile di ambiente del token API**: di seguito è riportato un esempio tratto dalla riga di comando: ``` $ export TOKEN="" ``` 1. **Ottieni il tuo Run ID**: dalla Terraform Cloud console, individua l'ID di esecuzione per la Terraform corsa che desideri utilizzare con AWS SAMCLI. L'ID di corsa si trova nel percorso breadcrumb della corsa. ![\[Percorso Breadcrumb in cui viene visualizzato l'ID di corsa. Terraform Cloud\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/images/terraform-01.png) 1. **Recupera il file del piano**: utilizzando il token API, ottieni il file del piano locale. Di seguito è riportato un esempio tratto dalla riga di comando: ``` curl \ --header "Authorization: Bearer $TOKEN" \ --header "Content-Type: application/vnd.api+json" \ --location \ https://app.terraform.io/api/v2/runs//plan/json-output \ > custom_plan.json ``` Ora sei pronto per usare AWS SAMCLI conTerraform Cloud. Quando utilizzate un AWS SAMCLI comando supportato, utilizzate l'`--terraform-plan-file`opzione per specificare il nome e il percorso del file del piano locale. Di seguito è riportato un esempio: ``` $ sam local invoke --hook-name terraform --terraform-plan-file custom-plan.json ``` Di seguito è riportato un esempio di utilizzo del `sam local start-api` comando: ``` $ sam local start-api --hook-name terraform --terraform-plan-file custom-plan.json ``` *Per un'applicazione di esempio da utilizzare con questi esempi, consulta [api\$1gateway\$1v2\$1tf\$1cloud nel repository aws-samples](https://github.com/aws-samples/aws-sam-terraform-examples/tree/main/ga/api_gateway_v2_tf_cloud). GitHub* ### Fasi successive Per iniziare a usare AWS SAMCLI withTerraform Cloud, consulta[Utilizzo di AWS SAMCLI with Terraform per il debug e il test locali](using-samcli-terraform.md). # Utilizzo di AWS SAMCLI with Terraform per il debug e il test locali Questo argomento spiega come utilizzare i AWS Serverless Application Model comandi Command Line Interface (AWS SAMCLI) supportati con i Terraform progetti eTerraform Cloud. Per fornire feedback e inviare richieste di funzionalità, crea un [GitHubproblema](https://github.com/aws/aws-sam-cli/issues/new?labels=area%2Fterraform). **Topics** + [Test locali con sam local invoke](#using-samcli-terraform-local-invoke) + [Test locali con sam local start-api](#using-samcli-terraform-local-start-api) + [Test locali con sam local start-lambda](#using-samcli-terraform-local-start-lambda) + [Limitazioni di Terraform](#using-samcli-terraform-unsupported) ## Test locali con sam local invoke **Nota** Per utilizzare il AWS SAMCLI test localmente, è necessario che Docker sia installato e configurato. Per istruzioni, consulta [Installazione di Docker da utilizzare con AWS SAMCLI](install-docker.md). Di seguito è riportato un esempio di test della funzione Lambda a livello locale trasmettendo un evento: ``` $ sam local invoke --hook-name terraform hello_world_function -e events/event.json - ``` Per ulteriori informazioni sull'utilizzo di questo comando, consulta[Introduzione ai test con sam local invoke](using-sam-cli-local-invoke.md). ## Test locali con sam local start-api Per utilizzarlo `sam local start-api` conTerraform, esegui quanto segue: ``` $ sam local start-api --hook-name terraform ``` Di seguito è riportato un esempio: ``` $ sam local start-api --hook-name terraform Running Prepare Hook to prepare the current application Executing prepare hook of hook "terraform" Initializing Terraform application ... Creating terraform plan and getting JSON output .... Generating metadata file Unresolvable attributes discovered in project, run terraform apply to resolve them. Finished generating metadata file. Storing in... Prepare hook completed and metadata file generated at: ... Mounting HelloWorldFunction at http://127.0.0.1:3000/hello [GET] Mounting None at http://127.0.0.1:3000/hello [POST] 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 SAM CLI if you update your AWS SAM template 2023-06-26 13:21:20 * Running on http://127.0.0.1:3000/ (Press CTRL+C to quit) ``` Per ulteriori informazioni su questo comando, vedere[Introduzione ai test con sam local start-api](using-sam-cli-local-start-api.md). ### Funzioni Lambda che utilizzano gli autorizzatori Lambda Per le funzioni Lambda configurate per utilizzare gli autorizzatori Lambda, richiameranno AWS SAMCLI automaticamente l'autorizzatore Lambda prima di richiamare l'endpoint della funzione Lambda. + Per ulteriori informazioni su questa funzionalità, consulta. AWS SAMCLI [Funzioni Lambda che utilizzano gli autorizzatori Lambda](using-sam-cli-local-start-api.md#using-sam-cli-local-start-api-authorizers) + *Per ulteriori informazioni sull'utilizzo degli autorizzatori Lambda inTerraform, consulta [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/api_gateway_authorizer#example-usage](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/api_gateway_authorizer#example-usage)nel registro. Terraform* ## Test locali con sam local start-lambda Di seguito è riportato un esempio di test della funzione Lambda localmente con AWS Command Line Interface ()AWS CLI: 1. Usa il AWS SAMCLI per creare un ambiente di test locale: ``` $ sam local start-lambda --hook-name terraform hello_world_function ``` 1. Usa AWS CLI per richiamare la tua funzione localmente: ``` $ aws lambda invoke --function-name hello_world_function --endpoint-url http://127.0.0.1:3001/ response.json --cli-binary-format raw-in-base64-out --payload file://events/event.json ``` Per ulteriori informazioni su questo comando, vedere[Introduzione ai test con sam local start-lambda](using-sam-cli-local-start-lambda.md). ## Limitazioni di Terraform Di seguito sono riportate le limitazioni relative all'utilizzo di AWS SAMCLI conTerraform: + Funzioni Lambda collegate a più livelli. + Terraformvariabili locali che definiscono i collegamenti tra le risorse. + Riferimento a una funzione Lambda che non è stata ancora creata. Ciò include le funzioni definite nell'attributo body della risorsa API REST. Per evitare queste limitazioni, puoi eseguire l'esecuzione `terraform apply` quando viene aggiunta una nuova risorsa. # Utilizzo di AWS SAMCLI with Serverless.tf per il debug e il test locali La AWS Serverless Application Model Command Line Interface (AWS SAMCLI) può essere utilizzata con i moduli Serverless.tf per il debug e il test locali di funzioni e livelli. AWS Lambda Sono supportati i seguenti comandi AWS SAMCLI: + `sam build` + `sam local invoke` + `sam local start-api` + `sam local start-lambda` **Nota** La versione 4.6.0 e successive di Serverless.TF supporta l'integrazione. AWS SAMCLI Per iniziare a utilizzarlo AWS SAMCLI con i tuoi moduli Serverless.TF, esegui l'aggiornamento alla versione più recente di Serverless.TF e il. AWS SAMCLI A partire dalla versione 6.0.0 di **serverless.tf**, è necessario impostare il parametro come. `create_sam_metadata` `true` Ciò genera le risorse di metadati richieste dal comando. AWS SAMCLI `sam build` Per ulteriori informazioni su Serverless.tf, consulta [terraform-aws-lambda-module](https://registry.terraform.io/modules/terraform-aws-modules/lambda/aws/latest). # AWS SAMCLIcon riferimento Terraform Questa sezione è il riferimento per l'utilizzo dell'interfaccia a riga di AWS Serverless Application Model comando (AWS SAMCLI) Terraform per il debug e il test locali. [Per fornire feedback e inviare richieste di funzionalità, crea un problema. GitHub](https://github.com/aws/aws-sam-cli/issues/new?labels=area%2Fterraform) ## AWS SAM riferimento alle funzionalità supportate La documentazione di riferimento per AWS SAMCLI le funzionalità che sono supportate per l'uso Terraform è disponibile qui: + [sam build](sam-cli-command-reference-sam-build.md) + [sam local invoke](sam-cli-command-reference-sam-local-invoke.md) + [sam local start-api](sam-cli-command-reference-sam-local-start-api.md) + [sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md) ## Terraformriferimento specifico La documentazione di riferimento specifica per l'utilizzo AWS SAMCLI con Terraform è disponibile qui: + [risorsa di metadati sam](terraform-sam-metadata.md) # risorsa di metadati sam Questa pagina contiene informazioni di riferimento per il tipo di **sam metadata resource** risorsa utilizzato con Terraform i progetti. + Per un'introduzione all'uso dell'interfaccia a riga di AWS Serverless Application Model comando (AWS SAMCLI) conTerraform, vedere[A cosa serve AWS SAMCLI il supportoTerraform?](terraform-support.md#what-is-terraform-support). + Per usare AWS SAMCLI withTerraform, vedi[Utilizzo di AWS SAMCLI with Terraform per il debug e il test locali](using-samcli-terraform.md). **Topics** + [Arguments (Argomenti)](#terraform-sam-metadata-arguments) + [Esempi](#terraform-sam-metadata-examples) ## Arguments (Argomenti) **** | Argomento | Description | | --- | --- | | built\$1output\$1path | Il percorso verso gli artefatti incorporati della tua AWS Lambda funzione. | | docker\$1build\$1args | Stringa decodificata dell'oggetto JSON degli argomenti di compilazione di Docker. Questo argomento è facoltativo. | | docker\$1context | Il percorso della directory contenente il contesto di creazione dell'immagine Docker. | | docker\$1file | Il percorso del file Docker. Questo percorso è relativo al `docker_context` percorso. Questo argomento è facoltativo. Il valore predefinito è `Dockerfile`. | | docker\$1tag | Il valore del tag di immagine Docker creato. Questo valore è facoltativo. | | depends\$1on | Il percorso verso la risorsa di costruzione per la funzione o il layer Lambda. Per ulteriori informazioni, consulta [L'**depends\$1on**argomento](https://developer.hashicorp.com/terraform/language/meta-arguments/depends_on) nel Terraformregistro. | | original\$1source\$1code | Il percorso in cui viene definita la funzione Lambda. Questo valore può essere una stringa, una matrice di stringhe o un oggetto JSON decodificato come stringa. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/terraform-sam-metadata.html) | | resource\$1name | Il nome della funzione Lambda. | | resource\$1type | Il formato del tipo di pacchetto di funzioni Lambda. I valori accettati sono: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/serverless-application-model/latest/developerguide/terraform-sam-metadata.html) | | source\$1code\$1property | Il percorso del codice risorsa Lambda nell'oggetto JSON. Definisci questa proprietà quando original\$1source\$1code è un oggetto JSON. | ## Esempi ### risorsa di metadati sam che fa riferimento a una funzione Lambda utilizzando il tipo di pacchetto ZIP ``` # Lambda function resource resource "aws_lambda_function" "tf_lambda_func" { filename = "${path.module}/python/hello-world.zip" handler = "index.lambda_handler" runtime = "python3.8" function_name = "function_example" role = aws_iam_role.iam_for_lambda.arn depends_on = [ null_resource.build_lambda_function # function build logic ] } # sam metadata resource resource "null_resource" "sam_metadata_function_example" { triggers = { resource_name = "aws_lambda_function.function_example" resource_type = "ZIP_LAMBDA_FUNCTION" original_source_code = "${path.module}/python" built_output_path = "${path.module}/building/function_example" } depends_on = [ null_resource.build_lambda_function # function build logic ] } ``` ### risorsa di metadati sam che fa riferimento a una funzione Lambda utilizzando il tipo di pacchetto image ``` resource "null_resource" "sam_metadata_function { triggers = { resource_name = "aws_lambda_function.image_function" resource_type = "IMAGE_LAMBDA_FUNCTION" docker_context = local.lambda_src_path docker_file = "Dockerfile" docker_build_args = jsonencode(var.build_args) docker_tag = "latest" } } ``` ### risorsa di metadati sam che fa riferimento a un livello Lambda ``` resource "null_resource" "sam_metadata_layer1" { triggers = { resource_name = "aws_lambda_layer_version.layer" resource_type = "LAMBDA_LAYER" original_source_code = local.layer_src built_output_path = "${path.module}/${layer_build_path}" } depends_on = [null_resource.layer_build] } ``` ## A cosa serve AWS SAMCLI il supportoTerraform? Usa la AWS Serverless Application Model Command Line Interface (AWS SAMCLI) con i tuoi Terraform progetti o Terraform Cloud per eseguire il debug e il test locali di: + AWS Lambda funzioni e livelli. + Amazon API Gateway APIs. Per un'introduzione aTerraform, vedi [Cos'èTerraform?](https://developer.hashicorp.com/terraform/intro) sul sito *HashiCorpTerraformWeb*. Per fornire feedback e inviare richieste di funzionalità, crea un [GitHubproblema](https://github.com/aws/aws-sam-cli/issues/new?labels=area%2Fterraform). **Nota** Come parte della fase di analisi AWS SAMCLI dell'integrazione, AWS SAMCLI i comandi utente dei processi generano file e dati di progetto. L'output del comando dovrebbe rimanere invariato, ma in alcuni ambienti, l'ambiente o il runner possono inserire registri o informazioni aggiuntivi nell'output. **Topics** + [Che cos'è il? AWS SAMCLI](#what-is-terraform-support-sam-cli) + [Come si usa il AWS SAMCLI conTerraform?](#what-is-terraform-support-how) + [Fasi successive](#what-is-terraform-support-next) ### Che cos'è il? AWS SAMCLI AWS SAMCLIÈ uno strumento a riga di comando che puoi utilizzare con AWS SAM modelli e integrazioni di terze parti supportateTerraform, ad esempio per creare ed eseguire applicazioni serverless. Per un'introduzione a AWS SAMCLI, vedere. [Che cos'è il? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli) AWS SAMCLISupporta i seguenti comandi perTerraform: + `sam local invoke`— Avvia localmente una sola chiamata di una AWS Lambda risorsa funzionale. Per ulteriori informazioni su questo comando, vedere. [Introduzione ai test con sam local invoke](using-sam-cli-local-invoke.md) + `sam local start-api`— Esegui le tue risorse Lambda localmente ed esegui il test tramite un host server HTTP locale. Questo tipo di test è utile per le funzioni Lambda richiamate da un endpoint API Gateway. Per ulteriori informazioni su questo comando, consulta. [Introduzione ai test con sam local start-api](using-sam-cli-local-start-api.md) + `sam local start-lambda`— Avvia un endpoint locale per la tua funzione Lambda per richiamarla localmente AWS Command Line Interface usando AWS CLI() o. SDKs Per ulteriori informazioni su questo comando, consulta. [Introduzione ai test con sam local start-lambda](using-sam-cli-local-start-lambda.md) ### Come si usa il AWS SAMCLI conTerraform? Il [Terraformflusso di lavoro principale](https://developer.hashicorp.com/terraform/intro/core-workflow) è costituito da tre fasi: **scrittura**, **pianificazione** e **applicazione**. Con AWS SAMCLI il supporto perTerraform, puoi sfruttare il AWS SAMCLI `sam local` set di comandi continuando a utilizzare i Terraform flussi di lavoro per gestire le tue applicazioni su AWS. In genere, ciò significa quanto segue: + **Scrittura**: crea la tua infrastruttura come codice utilizzandoTerraform. + **Test ed esegui il debug**: utilizzalo per testare ed AWS SAMCLI eseguire il debug delle tue applicazioni a livello locale. + **Pianifica**: visualizza in anteprima le modifiche prima di applicarle. + **Applica**: effettua il provisioning della tua infrastruttura. Per un esempio di utilizzo di AWS SAMCLI withTerraform, consulta [Better together: AWS SAMCLI and HashiCorp Terraform](https://aws.amazon.com/blogs/compute/better-together-aws-sam-cli-and-hashicorp-terraform/) at the *AWS Compute Blog*. ### Fasi successive Per completare tutti i prerequisiti e la configurazioneTerraform, vedere. [Guida introduttiva Terraform al supporto per AWS SAMCLI](gs-terraform-support.md)