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à.
# Implementa codice trascritto TypeScript in Lambda con archivi di file.zip
Prima di poter distribuire il TypeScript codice in AWS Lambda, devi trasporlo in. JavaScript Questa pagina spiega tre modi per creare e distribuire TypeScript codice in Lambda con archivi di file.zip:
+ [Usare () AWS Serverless Application ModelAWS SAM](#aws-sam-ts)
+ [Usando il AWS Cloud Development Kit (AWS CDK)](#aws-cdk-ts)
+ [Usando AWS Command Line Interface (AWS CLI) ed esbuild](#aws-cli-ts)
AWS SAM e AWS CDK semplifica la creazione e l'implementazione delle funzioni. TypeScript La [specifica del AWS SAM modello](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) fornisce una sintassi semplice e chiara per descrivere le funzioni APIs, le autorizzazioni, le configurazioni e gli eventi Lambda che costituiscono l'applicazione serverless. [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/home.html) consente di creare applicazioni affidabili, scalabili e convenienti nel cloud con la notevole potenza espressiva di un linguaggio di programmazione. AWS CDK È destinato a utenti con esperienza da moderata a elevata. AWS Sia gli che AWS CDK i AWS SAM usano esbuild per trascrivere il codice TypeScript in. JavaScript
## Utilizzo AWS SAM per distribuire TypeScript codice in Lambda
Segui i passaggi seguenti per scaricare, creare e distribuire un' TypeScript applicazione Hello World di esempio utilizzando. AWS SAM Questa applicazione implementa un backend API di base. Consiste in un endpoint Gateway Amazon API e in una funzione Lambda. Quando si invia una richiesta GET all'endpoint API Gateway, viene richiamata la funzione Lambda. La funzione restituisce un messaggio `hello world`.
**Nota**
AWS SAM usa esbuild per creare le funzioni Lambda di Node.js TypeScript dal codice. il supporto di esbuild è attualmente in anteprima pubblica. Durante l'anteprima pubblica, il supporto di esbuild potrebbe essere soggetto a modifiche incompatibili con il passato.
**Prerequisiti**
Per completare le fasi riportate in questa sezione, è necessario:
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI versione 1.75 o successiva](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
+ Node.js
**Implementa un'applicazione di esempio AWS SAM**
1. Inizializza l'applicazione utilizzando il modello Hello World. TypeScript
```
sam init --app-template hello-world-typescript --name sam-app --package-type Zip --runtime nodejs24.x
```
1. (Facoltativo) L'applicazione di esempio include configurazioni per strumenti di uso comune, come per il linting del codice e [Jest [ESLlint](https://eslint.org/)](https://jestjs.io/)per il test delle unità. Per eseguire i comandi lint e test:
```
cd sam-app/hello-world
npm install
npm run lint
npm run test
```
1. Costruisci l'app.
```
cd sam-app
sam build
```
1. Distribuire l'app.
```
sam deploy --guided
```
1. Seguire le istruzioni visualizzate sullo schermo. Per accettare le opzioni predefinite fornite nell'esperienza interattiva, rispondi con `Enter`.
1. L'output mostra l'endpoint per la REST API. Apri l'endpoint in un browser per testare la funzione. Dovresti vedere questa risposta:
```
{"message":"hello world"}
```
1. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test.
```
sam delete
```
## Utilizzo di AWS CDK per distribuire il TypeScript codice in Lambda
Segui i passaggi seguenti per creare e distribuire un' TypeScript applicazione di esempio utilizzando. AWS CDK Questa applicazione implementa un backend API di base. È costituito da un endpoint API Gateway e da una funzione Lambda. Quando si invia una richiesta GET all'endpoint API Gateway, viene richiamata la funzione Lambda. La funzione restituisce un messaggio `hello world`.
**Prerequisiti**
Per completare le fasi riportate in questa sezione, è necessario:
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK versione 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ Node.js
+ [Docker](https://www.docker.com/get-started/) o [esbuild](https://esbuild.github.io/)
**Implementa un'applicazione di esempio AWS CDK**
1. Crea una directory di progetto per la nuova applicazione.
```
mkdir hello-world
cd hello-world
```
1. Inizializza l'app.
```
cdk init app --language typescript
```
1. Aggiungi il pacchetto [@types /aws-lambda](https://www.npmjs.com/package/@types/aws-lambda) come dipendenza di sviluppo. Questo pacchetto contiene le definizioni dei tipi per Lambda.
```
npm install -D @types/aws-lambda
```
1. Apri la directory **lib**. Dovresti vedere un file chiamato **hello-world-stack.ts.** Crea due nuovi file in questa directory: **hello-world.function.ts** e **hello-world.ts**.
1. Apri **hello-world.function.ts** e aggiungi il seguente codice al file. Questo è il codice per la funzione Lambda.
**Nota**
L'istruzione `import` importa le definizioni dei tipi da [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda). Non importa il pacchetto NPM `aws-lambda`, che è uno strumento di terzi non correlato. Per ulteriori informazioni, consulta [aws-lambda](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/aws-lambda) nel repository. DefinitelyTyped GitHub
```
import { Context, APIGatewayProxyResult, APIGatewayEvent } from 'aws-lambda';
export const handler = async (event: APIGatewayEvent, context: Context): Promise => {
console.log(`Event: ${JSON.stringify(event, null, 2)}`);
console.log(`Context: ${JSON.stringify(context, null, 2)}`);
return {
statusCode: 200,
body: JSON.stringify({
message: 'hello world',
}),
};
};
```
1. Apri **hello-world.ts** e aggiungi il seguente codice al file. Contiene il [NodejsFunction costrutto](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_nodejs-readme.html), che crea la funzione Lambda, e il costrutto, che crea [LambdaRestApi l'](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.LambdaRestApi.html)API REST.
```
import { Construct } from 'constructs';
import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
import { LambdaRestApi } from 'aws-cdk-lib/aws-apigateway';
export class HelloWorld extends Construct {
constructor(scope: Construct, id: string) {
super(scope, id);
const helloFunction = new NodejsFunction(this, 'function');
new LambdaRestApi(this, 'apigw', {
handler: helloFunction,
});
}
}
```
Il costrutto `NodejsFunction` presuppone quanto segue per impostazione predefinita:
+ Viene richiamato il gestore di funzioni `handler`.
+ Il file .ts che contiene il codice funzione (**hello-world.function.ts**) si trova nella stessa directory del file .ts che contiene il costrutto (**hello-world.ts**). Il costrutto utilizza l'ID del costrutto ("hello-world") e il nome del file del gestore Lambda ("funzione") per trovare il codice funzione. Ad esempio, se il codice funzione si trova in un file chiamato **hello-world.my-function.ts**, il file **hello-world.ts** deve fare riferimento al codice funzione in questo modo:
```
const helloFunction = new NodejsFunction(this, 'my-function');
```
È possibile modificare questo comportamento e configurare altri parametri esbuild. Per ulteriori informazioni, consulta [Configurazione di esbuild](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_nodejs-readme.html#configuring-esbuild) nel riferimento all'API. AWS CDK
1. **Apri .tshello-world-stack.** Questo è il codice che definisce lo [stack AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/stacks.html). Sostituisci il codice con il seguente:
```
import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import { HelloWorld } from './hello-world';
export class HelloWorldStack extends Stack {
constructor(scope: Construct, id: string, props?: StackProps) {
super(scope, id, props);
new HelloWorld(this, 'hello-world');
}
}
```
1. dalla directory `hello-world` contenente il file `cdk.json`, implementa l'applicazione.
```
cdk deploy
```
1. AWS CDK Compila e impacchetta la funzione Lambda utilizzando esbuild, quindi distribuisce la funzione nel runtime Lambda. L'output mostra l'endpoint per la REST API. Apri l'endpoint in un browser per testare la funzione. Dovresti vedere questa risposta:
```
{"message":"hello world"}
```
Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test.
## Utilizzo di AWS CLI ed esbuild per distribuire il TypeScript codice in Lambda
L'esempio seguente dimostra come traspilare e distribuire codice in TypeScript Lambda utilizzando esbuild e. esbuild produce un file con tutte le AWS CLI dipendenze. JavaScript Questo è l'unico file che devi aggiungere all'archivio .zip.
**Prerequisiti**
Per completare le fasi riportate in questa sezione, è necessario:
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Node.js
+ Un [ruolo di esecuzione](lambda-intro-execution-role.md) per la funzione Lambda
+ Per gli utenti Windows, un'utilità di file zip come [7zip](https://www.7-zip.org/download.html).
**Implementare una funzione di esempio**
1. Sul tuo computer locale, crea una directory di progetto per la nuova funzione.
1. Crea un nuovo progetto Node.js con npm o un gestore di pacchetti di tua scelta.
```
npm init
```
1. Aggiungi i pacchetti [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda) e [esbuild](https://esbuild.github.io/) come dipendenze di sviluppo. Il pacchetto `@types/aws-lambda` contiene le definizioni dei tipi per Lambda.
```
npm install -D @types/aws-lambda esbuild
```
1. Crea un nuovo file denominato **index.ts**. Aggiungi il seguente codice al nuovo file. Questo è il codice per la funzione Lambda. La funzione restituisce un messaggio `hello world`. La funzione non crea risorse API Gateway.
**Nota**
L'istruzione `import` importa le definizioni dei tipi da [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda). Non importa il pacchetto NPM `aws-lambda`, che è uno strumento di terzi non correlato. Per ulteriori informazioni, consulta [aws-lambda nel repository](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/aws-lambda). DefinitelyTyped GitHub
```
import { Context, APIGatewayProxyResult, APIGatewayEvent } from 'aws-lambda';
export const handler = async (event: APIGatewayEvent, context: Context): Promise => {
console.log(`Event: ${JSON.stringify(event, null, 2)}`);
console.log(`Context: ${JSON.stringify(context, null, 2)}`);
return {
statusCode: 200,
body: JSON.stringify({
message: 'hello world',
}),
};
};
```
1. Aggiungi uno script di compilazione al file **package.json**. esbuild viene configurato per creare automaticamente il pacchetto di implementazione .zip. Per ulteriori informazioni, consulta la sezione relativa alla [compilazione degli script](https://esbuild.github.io/getting-started/#build-scripts) nella documentazione di esbuild.
------
#### [ Linux and MacOS ]
```
"scripts": {
"prebuild": "rm -rf dist",
"build": "esbuild index.ts --bundle --minify --sourcemap --platform=node --target=es2020 --outfile=dist/index.js",
"postbuild": "cd dist && zip -r index.zip index.js*"
},
```
------
#### [ Windows ]
In questo esempio, il comando `"postbuild"` utilizza l'utilità [7zip](https://www.7-zip.org/download.html) per creare il file con estensione .zip. Utilizza l'utilità zip di Windows preferita e modifica il comando secondo necessità.
```
"scripts": {
"prebuild": "del /q dist",
"build": "esbuild index.ts --bundle --minify --sourcemap --platform=node --target=es2020 --outfile=dist/index.js",
"postbuild": "cd dist && 7z a -tzip index.zip index.js*"
},
```
------
1. Creare il pacchetto.
```
npm run build
```
1. Crea una funzione Lambda utilizzando il pacchetto di implementazione .zip. Sostituisci il testo evidenziato con l'Amazon Resource Name (ARN) del tuo [ruolo di esecuzione](lambda-intro-execution-role.md).
```
aws lambda create-function --function-name hello-world --runtime "nodejs24.x" --role arn:aws:iam::123456789012:role/lambda-ex --zip-file "fileb://dist/index.zip" --handler index.handler
```
1. [Esegui un evento di test](testing-functions.md) per confermare che la funzione restituisca la risposta seguente. Se desideri richiamare questa funzione utilizzando API Gateway, [crea e configura una REST API](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-create-api.html).
```
{
"statusCode": 200,
"body": "{\"message\":\"hello world\"}"
}
```