Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Création d'une fonction Web Lambda
Pour déployer une application avec Lambda Web Functions, vous devez créer une fonction Web avec une révision et un point de terminaison pour recevoir le trafic. La console et la `aws lambda-web deploy` commande peuvent créer la fonction Web, sa première révision et son premier point de terminaison. Les révisions sont des instantanés immuables de votre code et de votre configuration. Un point de terminaison achemine les demandes vers une révision active. Pour plus d’information sur ces ressources, consultez [Concepts de base](web-functions-how-it-works.md). Cette rubrique explique comment les créer à l'aide de la console Lambda et du. AWS CLI
## Conditions préalables
Avant de commencer, assurez-vous de disposer des éléments suivants :
+ Un AWS compte. Pour en créer une, voir [Comparer les options d'inscription](https://docs.aws.amazon.com/accounts/latest/reference/sign-up-for-aws.html) dans le *Guide de référence sur la gestion des AWS comptes*.
+ Autorisations permettant de gérer les fonctions Web, de transmettre le rôle d'exécution à Lambda (`iam:PassRole`) et de créer ou d'utiliser les ressources Amazon S3 et IAM associées.
La console crée ou réutilise les ressources dont votre fonction Web a besoin, notamment un rôle d'exécution et un compartiment Amazon S3 pour votre code.
Pour suivre la AWS CLI procédure, vous devez également :
+ AWS CLI version 2, dans une version qui inclut les `aws lambda-web` commandes. Pour vérifier, courez`aws lambda-web help`. Si vous l'avez installé AWS CLI à l'aide d'un programme d'installation ou d'un script d'installation officiel, exécutez-le `aws update` pour effectuer la mise à jour vers la dernière version. Sinon, consultez la section [Installation ou mise à jour vers la dernière version du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ AWS des informations d'identification et une Région AWS configuration pour le AWS CLI.
+ Pour`aws lambda-web deploy`, l'autorisation d'appeler`sts:GetCallerIdentity`, `s3:ListBucket` sur le compartiment de déploiement `s3:PutObject``s3:GetObject`, et `s3:GetObjectVersion` sur ses objets.
+ Si `aws lambda-web deploy` crée les ressources par défaut, l'autorisation d'appeler `iam:GetRole``iam:CreateRole`,`iam:PutRolePolicy`,`s3:CreateBucket`,`s3:PutBucketPolicy`, et`s3:PutBucketVersioning`.
+ (Facultatif) Node.js 24 ou plus tard pour le développement local. Pour procéder à l'installationNode.js, consultez [la section Téléchargement Node.js](https://nodejs.org/en/download/) sur le Node.js site Web.
## Création d'une fonction Web (console)
Utilisez la console Lambda pour créer une fonction Web, sa première révision et son premier point de terminaison à recevoir du trafic.
**Pour créer une fonction Web et un point de terminaison (console)**
1. Ouvrez la console Lambda à l'adresse. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Dans le volet de navigation, sélectionnez **Web Functions**.
1. Choisissez **Create Web Function**.
1. Sous **Basic information** (Informations de base), procédez comme suit :
1. Dans **Nom de la fonction**, entrez le nom de votre fonction Web.
1. Pour **Runtime**, conservez le runtime par défaut.
1. Pour **le code source**, conservez **le modèle Hello World** pour commencer à partir d'un exemple d'application préconfiguré. Pour déployer votre propre code à la place, choisissez **Upload ZIP file** ou **Amazon S3**.
1. Sous **Configuration du point de terminaison**, procédez comme suit :
1. Dans **Nom du point de terminaison**, entrez un nom pour le point de terminaison.
1. Pour **Type**, conservez **Home-Region**. Un Home-Region point de terminaison s'exécute dans une seule région, ce qui en fait la configuration la plus simple pour votre première fonction Web. Pour les options multirégionales, voir[Points de terminaison de la fonction Web Lambda](web-functions-endpoints.md).
**Note**
Vous ne pouvez pas modifier le type de point de terminaison après sa création.
1. Pour **Type d'authentification**, choisissez **Application-managed Authentification**. Avec cette option, Lambda transmet toutes les demandes à votre application, afin que celle-ci gère l'authentification. Pour restreindre l'accès, choisissez plutôt l'**authentification IAM**, qui oblige les appelants à signer les demandes. Les demandes `HomeRegion` et les `PerRegion` points de terminaison utilisent AWS Signature Version 4 (SigV4). Les demandes adressées aux `MultiRegion` points de terminaison utilisent la version de signature 4a (SIGv4a). Pour plus d’informations, consultez [Contrôle d'accès aux terminaux Lambda Web Function](web-functions-endpoint-access-control.md).
1. Pour le **déploiement automatique**, conservez **la dernière révision**. **Avec ce mode, Lambda achemine automatiquement tout le trafic vers chaque nouvelle révision une fois qu'elle est devenue active.** Pour un contrôle manuel du trafic avec des pondérations de révision, choisissez **Disabled**. Pour plus d’informations, consultez [Modèles de déploiement](web-functions-deployment.md).
1. (Facultatif) Développez **les configurations supplémentaires** pour remplacer les paramètres par défaut. Par défaut, Lambda crée un rôle d'exécution autorisé à télécharger des journaux sur Amazon CloudWatch, et un compartiment Amazon S3 dans votre compte pour stocker votre code. Dans cette section, vous pouvez choisir un rôle IAM existant ou votre propre compartiment Amazon S3, et vous pouvez également configurer le chiffrement avec une clé gérée par le client, la simultanéité maximale par environnement, les variables d'environnement et les balises.
1. Choisissez **Create Web Function**.
Lorsque vous choisissez **Create Web Function**, Lambda crée la ressource Web Function avec sa première révision, et crée le point de terminaison en même temps. **La révision commence à l'état **En attente** pendant que Lambda télécharge votre code et prépare un artefact de code à partir de celui-ci, puis passe à Active.** Le point de terminaison démarre également à l'état **En attente**. La fonction Web, sa révision et son point de terminaison progressent chacun dans ces états indépendamment. Pour plus d'informations sur les révisions et les états du cycle de vie, consultez[Concepts de base](web-functions-how-it-works.md).
Le point de terminaison commence à desservir le trafic lorsqu'il devient **actif** et qu'il existe une révision **active** vers laquelle il peut être acheminé. Pour trouver le nom de domaine du point de terminaison, sur la page détaillée de la fonction, choisissez l'onglet **Points de terminaison**, puis choisissez le point de terminaison. Pour diffuser l'application sur votre propre domaine, placez une CloudFront distribution Amazon devant le point de terminaison. Pour plus d'informations sur les types de points de terminaison et les noms de domaine, consultez[Points de terminaison de la fonction Web Lambda](web-functions-endpoints.md).
Pour vérifier que votre application diffuse du trafic, envoyez une demande au nom de domaine. Comme vous avez choisi **Application-managed l'authentification**, vous pouvez envoyer une simple demande sans la signer.
```
curl https://{{your-endpoint-domain-name}}/
```
Une réponse réussie signifie que votre fonction Web reçoit du trafic et que votre application répond aux demandes.
## Création d'une fonction Web (AWS CLI)
Créez et déployez une fonction Web à partir de votre terminal. La commande de démarrage génère un petit serveur Node.js HTTP, le déploie et renvoie une URL de point de terminaison HTTPS.
### Déployez et testez votre fonction Web
**Pour déployer et tester une fonction Web de démarrage**
1. Exécutez la commande suivante :
```
aws lambda-web deploy --name my-web-app --hello-world
```
`--hello-world`écrit les fichiers de démarrage dans le répertoire`./my-web-app`, en créant le répertoire s'il n'existe pas. Le starter contient `server.ts` un serveur TypeScript HTTP, et `package.json``README.md`, et`AGENTS.md`.
1. Lorsque le déploiement est terminé, copiez l'URL du point de terminaison à partir de la sortie. L'URL ressemble à ce qui suit :
```
https://bcdfghjklmnpqrst.b7t.lambda-web.us-east-1.on.aws
```
1. Envoyez une demande à l'URL du point de terminaison que vous avez copié à l'étape précédente. Remplacez {{endpoint-url}} par cette URL :
```
curl {{endpoint-url}}
```
Le starter renvoie une réponse similaire à la suivante :
```
{"message":"Hello from Lambda Web!","path":"/"}
```
Par défaut, le point de terminaison de départ accepte les demandes sans authentification. Pour demander l'autorisation IAM, ajoutez`--auth-type IamAuth`. Pour plus d'informations sur le contrôle de l'accès à votre terminal, consultez[Contrôle d'accès aux terminaux Lambda Web Function](web-functions-endpoint-access-control.md).
### Ce que la commande crée
Lors du premier déploiement, la commande :
+ Crée ou réutilise un compartiment Amazon S3 avec la gestion des versions activée pour les packages de déploiement.
+ Crée ou réutilise un rôle d'exécution IAM avec les autorisations Amazon CloudWatch Logs.
+ Crée la fonction Web et sa première révision.
+ Crée un `HomeRegion` point de terminaison nommé `dev` et attend qu'il le devienne`Active`. Pour utiliser un autre nom, ajoutez`--endpoint-name`.
Une fonction Web contient des révisions immuables de votre code et de votre configuration. Lors des déploiements ultérieurs, la commande crée une autre révision. Le `dev` point de terminaison utilise le `LatestRevision` mode et diffuse la révision une fois qu'elle est devenue active.
### Déployer une modification
Après avoir modifié l'application de démarrage, exécutez :
```
aws lambda-web deploy \
--name my-web-app \
--code ./my-web-app
```
L'exécution de cette commande télécharge votre package mis à jour, crée une révision et attend que la révision devienne effective. `Active` Le `dev` point de terminaison a `autoDeploymentMode` défini la révision `LatestRevision` et la diffuse automatiquement. Son URL reste la même.
Pour déployer votre propre application au lieu du starter, transmettez son répertoire à`--code`. Votre serveur doit écouter l'hôte et le port dans la variable d'`AWS_LAMBDA_HTTP_ENDPOINT`environnement. Par défaut, le moteur d'exécution `index.js` se charge à la racine du package de déploiement. Pour utiliser un autre fichier d'entrée, définissez la variable d'`AWS_LAMBDA_NODEJS_ENTRYPOINT`environnement. Lambda ne vérifie pas que votre serveur commence à écouter lorsqu'il crée la révision. Par conséquent, la révision et le point de terminaison peuvent s'afficher `Active` même si les demandes échouent. Pour plus d’informations, consultez [Runtimes des fonctions Web Lambda](web-functions-runtimes.md).
### Utiliser l'existant AWS resources
Si vous gérez déjà un bucket Amazon S3 ou un rôle d'exécution IAM, utilisez la commande suivante pour réutiliser ces ressources au lieu de créer des valeurs par défaut. La gestion des versions du compartiment doit être activée et une politique de compartiment doit accorder le principal de service Lambda `lambda.amazonaws.com` () `s3:GetObject` et. `s3:GetObjectVersion` La commande ne modifie pas la configuration d'un compartiment que vous spécifiez. Pour les exigences relatives aux compartiments, voir[Politique relative aux compartiments pour Lambda](web-functions-code-s3.md#web-functions-code-s3-bucket-policy). Remplacez les exemples de valeurs de ressources par les vôtres.
```
aws lambda-web deploy \
--name my-web-app \
--code ./my-web-app \
--bucket-name amzn-s3-demo-bucket \
--execution-role-arn arn:aws:iam::111122223333:role/my-web-app-execution-role
```
Le rôle d'exécution doit permettre à Lambda de l'assumer et doit accorder les autorisations dont votre application a besoin. Pour plus d’informations, consultez [Rôle d'exécution](web-functions-permissions.md#web-functions-permissions-execution-role).
Vous pouvez omettre l'une ou l'autre des options de ressource pour permettre de `deploy` créer des valeurs par défaut. Lorsque vous `deploy` créez une fonction Web sans `--hello-world` point de terminaison ou que vous en ajoutez un, elle vous demande d'appuyer sur Entrée pour confirmer. Dans un script ou un CI/CD pipeline, ajoutez `--create` pour confirmer sans invite.
### Utilisez directement les commandes de l'API
La `deploy` commande télécharge votre code sur Amazon S3 et crée la fonction Web, la révision et le point de terminaison pour vous. Pour contrôler vous-même chaque étape, utilisez les AWS CLI commandes associées aux opérations de l'API, telles que `create-web-function``create-web-function-revision`, et`update-web-function-endpoint`. Dans les commandes suivantes, remplacez chaque espace réservé pour l’entrée utilisateur par vos propres informations.
**Pour créer une fonction Web à l'aide des commandes de l'API (AWS CLI)**
1. Créez un package de déploiement .zip à partir du répertoire de votre application, avec votre fichier d'entrée à la racine du package. Téléchargez le package dans un compartiment Amazon S3 répondant aux exigences de[Conditions préalables](web-functions-code-s3.md#web-functions-code-s3-requirements). Les commandes suivantes créent le package et utilisent le AWS CLI pour le télécharger.
```
cd {{my-app}}
zip -r ../my-app.zip .
aws s3 cp ../my-app.zip s3://{{amzn-s3-demo-bucket}}/my-app.zip
```
1. Utilisez la AWS CLI commande suivante pour créer la fonction Web avec sa première révision et son point de terminaison. Dans`revisionConfig`, `buildConfig` indique l'emplacement du code et le temps d'exécution, ainsi `serviceConfig` que le rôle d'exécution. La `endpointConfig` propriété définit le point de terminaison.
```
aws lambda-web create-web-function \
--function-name {{my-web-app}} \
--revision-config '{
"buildConfig": {
"codeConfig": {
"s3Object": { "bucket": "{{amzn-s3-demo-bucket}}", "key": "my-app.zip" }
},
"runtimeConfig": { "runtime": "nodejs24.x" }
},
"serviceConfig": {
"executionRoleArn": "arn:aws:iam::{{111122223333}}:role/{{my-web-app-execution-role}}"
}
}' \
--endpoint-config '{
"endpointName": "{{my-endpoint}}",
"endpointType": "HomeRegion",
"authType": "ApplicationManaged",
"autoDeploymentMode": "LatestRevision"
}'
```
La propriété `autoDeploymentMode` est facultative. Si vous l'omettez, la valeur par défaut est`Disabled`, et le point de terminaison n'achemine pas automatiquement le trafic vers les nouvelles révisions. Notez `revisionId` la version révisée dans la réponse.
1. Patientez jusqu'à ce que la révision soit terminée`Active`. {{rev-abc12}}Remplacez-le par l'ID de révision de l'étape précédente.
```
aws lambda-web wait web-function-revision-active \
--function-name {{my-web-app}} \
--revision-id {{rev-abc12}}
```
1. Obtenez les détails du point de terminaison.
```
aws lambda-web get-web-function-endpoint \
--function-name {{my-web-app}} \
--endpoint-name {{my-endpoint}}
```
Lorsque c'`state`est le cas du point de terminaison`Active`, envoyez des demandes à son`domainName`. La réponse ressemble à l'extrait suivant.
```
{
"endpointName": "my-endpoint",
"endpointType": "HomeRegion",
"domainName": "bcdfghjklmnpqrst.b7t.lambda-web.us-east-1.on.aws",
"authType": "ApplicationManaged",
"autoDeploymentMode": "LatestRevision",
"state": "Active",
"updateStatus": "Successful"
}
```
**Pour déployer une modification à l'aide des commandes de l'API (AWS CLI)**
+ Téléchargez un nouveau package et créez une révision. Une révision est un instantané complet, alors transmettez-le dans son intégralité `buildConfig` et à `serviceConfig` chaque fois.
```
aws s3 cp ../my-app.zip s3://{{amzn-s3-demo-bucket}}/my-app.zip
aws lambda-web create-web-function-revision \
--function-name {{my-web-app}} \
--build-config '{
"codeConfig": {
"s3Object": { "bucket": "{{amzn-s3-demo-bucket}}", "key": "my-app.zip" }
},
"runtimeConfig": { "runtime": "nodejs24.x" }
}' \
--service-config '{
"executionRoleArn": "arn:aws:iam::{{111122223333}}:role/{{my-web-app-execution-role}}"
}'
```
Comme le point de terminaison est `autoDeploymentMode` défini sur`LatestRevision`, il achemine tout le trafic vers la nouvelle révision une fois celle-ci passée`Active`. Si vous définissez `autoDeploymentMode` cette option`Disabled`, vous acheminez le trafic avec des `update-web-function-endpoint` pondérations de révision à la place. Pour plus d’informations, consultez [Modèles de déploiement](web-functions-deployment.md).
## Nettoyage
Lorsque vous n'avez plus besoin de la fonction Web, supprimez-la :
```
aws lambda-web delete-web-function --function-name my-web-app
```
Cette commande supprime également les points de terminaison et les révisions de la fonction Web. Il ne supprime pas les ressources `deploy` créées ou utilisées : le rôle d'exécution IAM (`awscli-lambdaweb-my-web-app`par défaut), les packages de déploiement contenus `lambda-web/my-web-app/` dans le compartiment Amazon S3 (`awscli-lambdaweb-{{account-id}}-{{region}}-an`par défaut), y compris les versions d'objets non actuelles, ou les groupes de CloudWatch journaux Amazon Logs pour la fonction Web. Supprimez ces ressources séparément uniquement si vous n'en avez plus besoin. Le compartiment Amazon S3 géré peut être partagé par d'autres déploiements de la même Compte AWS région.