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.
# Déployer des fonctions Lambda .NET avec des images conteneurs
Il existe trois méthodes pour créer une image de conteneur pour une fonction Lambda .NET :
+ [Utilisation d'une image AWS de base pour .NET](#csharp-image-instructions)
Les [images de base AWS](images-create.md#runtimes-images-lp) sont préchargées avec une exécution du langage, un client d’interface d’exécution pour gérer l’interaction entre Lambda et votre code de fonction, et un émulateur d’interface d’exécution pour les tests locaux.
+ [Utilisation d'une image de base AWS uniquement pour le système d'exploitation](images-create.md#runtimes-images-provided)
[AWS Les images de base réservées](https://gallery.ecr.aws/lambda/provided) au système d'exploitation contiennent une distribution Amazon Linux et l'émulateur [d'interface d'exécution](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Ces images sont couramment utilisées pour créer des images de conteneur pour les langages compilés, tels que [Go](go-image.md#go-image-provided) et [Rust](lambda-rust.md), et pour une langue ou une version linguistique pour laquelle Lambda ne fournit pas d’image de base, comme Node.js 19. Vous pouvez également utiliser des images de base uniquement pour le système d'exploitation pour implémenter un [environnement d'exécution personnalisé](runtimes-custom.md). Pour rendre l’image compatible avec Lambda, vous devez inclure le [client d’interface d’exécution pour .NET](#csharp-image-clients) dans l’image.
+ [Utilisation d'une image non AWS basique](#csharp-image-clients)
Vous pouvez utiliser une autre image de base à partir d’un autre registre de conteneur, comme Alpine Linux ou Debian. Vous pouvez également utiliser une image personnalisée créée par votre organisation. Pour rendre l’image compatible avec Lambda, vous devez inclure le [client d’interface d’exécution pour .NET](#csharp-image-clients) dans l’image.
**Astuce**
Pour réduire le temps nécessaire à l’activation des fonctions du conteneur Lambda, consultez [Utiliser des générations en plusieurs étapes](https://docs.docker.com/build/building/multi-stage/) (français non garanti) dans la documentation Docker. Pour créer des images de conteneur efficaces, suivez la section [Bonnes pratiques pour l’écriture de Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/) (français non garanti).
Cette page explique comment créer, tester et déployer des images de conteneur pour Lambda.
**Topics**
+ [
## AWS images de base pour .NET
](#csharp-image-base)
+ [
## Utilisation d'une image AWS de base pour .NET
](#csharp-image-instructions)
+ [
## Utilisation d’une autre image de base avec le client d’interface d’exécution
](#csharp-image-clients)
## AWS images de base pour .NET
AWS fournit les images de base suivantes pour .NET :
| Étiquettes | Environnement d’exécution | Système d’exploitation | Dockerfile | Obsolescence |
| --- | --- | --- | --- | --- |
| 10 | .NET 10 | Amazon Linux 2023 | [Dockerfile pour .NET 10 sur GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet10/Dockerfile.dotnet10) | 14 novembre 2028 |
| 9 | .NET 9 | Amazon Linux 2023 | [Dockerfile pour .NET 9 sur GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet9/Dockerfile.dotnet9) | 10 novembre 2026 |
| 8 | .NET 8 | Amazon Linux 2023 | [Dockerfile pour .NET 8 sur GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet8/Dockerfile.dotnet8) | 10 novembre 2026 |
Référentiel Amazon ECR : [gallery.ecr. aws/lambda/dotnet](https://gallery.ecr.aws/lambda/dotnet)
## Utilisation d'une image AWS de base pour .NET
### Conditions préalables
Pour exécuter la procédure indiquée dans cette section, vous devez satisfaire aux exigences suivantes :
+ [SDK .NET](https://dotnet.microsoft.com/download) : les étapes suivantes utilisent l’image de base .NET 8. Assurez-vous que votre version de .NET correspond à la version de l’[image de base](https://gallery.ecr.aws/lambda/dotnet) que vous spécifiez dans votre Dockerfile.
+ [Docker](https://docs.docker.com/get-docker) (version minimale 25.0.0)
+ Le [plug-in buildx](https://github.com/docker/buildx/blob/master/README.md) Docker.
### Création et déploiement d’une image à l’aide d’une image de base
Dans les étapes suivantes, vous utilisez [Amazon.Lambda.Templates](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) et [Amazon.Lambda.Tools](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools) pour créer un projet .NET. Ensuite, vous créez une image Docker, vous chargez l’image sur Amazon ECR et vous la déployez vers une fonction Lambda.
1. Installez le package [Amazon.Lambda.Templates.](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) NuGet
```
dotnet new install Amazon.Lambda.Templates
```
1. Créez un projet .NET en utilisant le modèle `lambda.image.EmptyFunction`.
```
dotnet new lambda.image.EmptyFunction --name MyFunction --region us-east-1
```
Les fichiers de projet sont stockés dans le répertoire `MyFunction/src/MyFunction` :
+ **aws-lambda-tools-defaults.json** : Spécifie les options de ligne de commande pour déployer votre fonction Lambda.
+ **Function.cs** : code de fonction de votre gestionnaire Lambda. Il s’agit d’un modèle C\$1 qui inclut la bibliothèque `Amazon.Lambda.Core` par défaut et un attribut `LambdaSerializer` par défaut. Pour plus d’informations sur les conditions de sérialisation et les options, consultez [Sérialisation dans les fonctions Lambda C\$1](csharp-handler.md#csharp-handler-serializer). Vous pouvez utiliser le code fourni pour les tests ou le remplacer par le vôtre.
+ **MyFunction.csproj** : [fichier de projet](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files) .NET répertoriant les fichiers et les assemblages composant votre application.
+ **Dockerfile** : vous pouvez utiliser le Dockerfile fourni pour les tests ou le remplacer par le vôtre. Si vous utilisez le vôtre, assurez-vous de :
+ Définir la propriété `FROM` sur l’[URI de l’image de base](https://gallery.ecr.aws/lambda/dotnet). L’image de base et `TargetFramework` dans le fichier `MyFunction.csproj` doivent tous deux utiliser la même version de .NET. Par exemple, pour utiliser .NET 9 :
+ Fichier Docker : `FROM public.ecr.aws/lambda/dotnet:9`
+ MyFunction.csproj : `net9.0`
+ Définir l’argument `CMD` pour le gestionnaire de la fonction Lambda. Il doit correspondre à `image-command` dans `aws-lambda-tools-defaults.json`.
1. Installer l’[outil global .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) d’Amazon.Lambda.Tools.
```
dotnet tool install -g Amazon.Lambda.Tools
```
Si Amazon.Lambda.Tools est déjà installé, assurez-vous que vous disposez de la dernière version.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Changez le répertoire en `MyFunction/src/MyFunction`, si vous n’y êtes pas déjà.
```
cd src/MyFunction
```
1. Utilisez Amazon.Lambda.Tools pour créer l’image Docker, l’envoyer (push) vers un nouveau référentiel Amazon ECR, et déployer la fonction Lambda.
Pour `--function-role`, indiquez le nom du rôle, et non l’Amazon Resource Name (ARN), du [rôle d’exécution](lambda-intro-execution-role.md) de la fonction. Par exemple, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
Pour plus d'informations sur l'outil global .NET Amazon.Lambda.Tools, consultez le référentiel Extensions [AWS for .NET](https://github.com/aws/aws-extensions-for-dotnet-cli) CLI sur. GitHub
1. Invoquer la fonction.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
Si tout réussit, vous verrez une réponse similaire à ce qui suit :
```
Payload:
{"Lower":"testing the function","Upper":"TESTING THE FUNCTION"}
Log Tail:
INIT_REPORT Init Duration: 9999.81 ms Phase: init Status: timeout
START RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed Version: $LATEST
END RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed
REPORT RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed Duration: 3173.06 ms Billed Duration: 3174 ms Memory Size: 512 MB Max Memory Used: 24 MB
```
1. Supprimez la fonction Lambda.
```
dotnet lambda delete-function MyFunction
```
## Utilisation d’une autre image de base avec le client d’interface d’exécution
Si vous utilisez une [image de base uniquement pour le système d’exploitation](images-create.md#runtimes-images-provided) ou une autre image de base, vous devez inclure le client d’interface d’exécution dans votre image. Le client d’interface d’exécution étend le[API de runtime](runtimes-api.md), qui gère l’interaction entre Lambda et votre code de fonction.
L'exemple suivant montre comment créer une image de conteneur pour .NET à l'aide d'une image non AWS basique et comment ajouter le [fichier Amazon.Lambda. RuntimeSupport ](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library)package, qui est le client d'interface d'exécution Lambda pour .NET. L’exemple de Dockerfile utilise l’image de base Microsoft .NET 8.
### Conditions préalables
Pour exécuter la procédure indiquée dans cette section, vous devez satisfaire aux exigences suivantes :
+ [SDK .NET](https://dotnet.microsoft.com/download) — Les étapes suivantes utilisent une image de base .NET 9. Assurez-vous que votre version de .NET correspond à la version de l’image de base que vous spécifiez dans votre Dockerfile.
+ [Docker](https://docs.docker.com/get-docker) (version minimale 25.0.0)
+ Le [plug-in buildx](https://github.com/docker/buildx/blob/master/README.md) Docker.
### Création et déploiement d’une image à l’aide d’une image de base alternative
1. Installez le package [Amazon.Lambda.Templates.](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) NuGet
```
dotnet new install Amazon.Lambda.Templates
```
1. Créez un projet .NET en utilisant le modèle `lambda.CustomRuntimeFunction`. Ce modèle inclut l'[Amazon.Lambda. RuntimeSupport](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library)colis.
```
dotnet new lambda.CustomRuntimeFunction --name MyFunction --region us-east-1
```
1. Accédez au répertoire `MyFunction/src/MyFunction`. C’est ici que les fichiers du projet sont stockés. Examinez les fichiers suivants :
+ **aws-lambda-tools-defaults.json** — Ce fichier vous permet de spécifier les options de ligne de commande lors du déploiement de votre fonction Lambda.
+ **Function.cs** : le code contient une classe avec une méthode `Main` qui initialise la bibliothèque `Amazon.Lambda.RuntimeSupport` en tant qu’amorce. La méthode `Main` est le point d’entrée du processus de la fonction. La méthode `Main` enveloppe le gestionnaire de fonctions dans un encapsuleur avec lequel l’amorce peut travailler. Pour plus d'informations, consultez la section [Utilisation d'Amazon.Lambda. RuntimeSupport en tant que bibliothèque de classes](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library) dans le GitHub référentiel.
+ **MyFunction.csproj** : [fichier de projet](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files) .NET répertoriant les fichiers et les assemblages composant votre application.
+ **Readme.md** : ce fichier contient plus d’informations sur l’exemple de fonction Lambda.
1. Ouvrez le fichier `aws-lambda-tools-defaults.json` et ajoutez les lignes suivantes :
```
"package-type": "image",
"docker-host-build-output-dir": "./bin/Release/lambda-publish"
```
+ **package-typee** : définit le package de déploiement en tant qu’image de conteneur.
+ **docker-host-build-output-dir** : définit le répertoire de sortie pour le processus de construction.
**Example aws-lambda-tools-defaults.json**
```
{
"Information": [
"This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.",
"To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.",
"dotnet lambda help",
"All the command line options for the Lambda command can be specified in this file."
],
"profile": "",
"region": "us-east-1",
"configuration": "Release",
"function-runtime": "provided.al2023",
"function-memory-size": 256,
"function-timeout": 30,
"function-handler": "bootstrap",
"msbuild-parameters": "--self-contained true",
"package-type": "image",
"docker-host-build-output-dir": "./bin/Release/lambda-publish"
}
```
1. Créez un Dockerfile dans le référentiel `MyFunction/src/MyFunction`. L’exemple de Dockerfile suivant utilise une image de base Microsoft .NET au lieu d’une [image de base AWS](#csharp-image-base).
+ Définissez la propriété `FROM` pour l’identifiant de l’image de base. L’image de base et `TargetFramework` dans le fichier `MyFunction.csproj` doivent tous deux utiliser la même version de .NET.
+ Utilisez la commande `COPY` pour copier la fonction dans le répertoire `/var/task`.
+ Définissez le `ENTRYPOINT` sur le module que vous souhaitez que le conteneur Docker exécute lorsqu’il démarre. Dans ce cas, le module est l’amorce, qui initialise la bibliothèque `Amazon.Lambda.RuntimeSupport`.
Notez que l’exemple de Dockerfile n’inclut pas d’[instruction USER](https://docs.docker.com/reference/dockerfile/#user). Lorsque vous déployez une image de conteneur sur Lambda, Lambda définit automatiquement un utilisateur Linux par défaut disposant d’autorisations de moindre privilège. Ceci est différent du comportement standard de Docker qui est défini par défaut par l’utilisateur `root` lorsqu’aucune instruction `USER` n’est fournie.
**Example Dockerfile**
```
# You can also pull these images from DockerHub amazon/aws-lambda-dotnet:8
FROM mcr.microsoft.com/dotnet/runtime:9.0
# Set the image's internal work directory
WORKDIR /var/task
# Copy function code to Lambda-defined environment variable
COPY "bin/Release/net9.0/linux-x64" .
# Set the entrypoint to the bootstrap
ENTRYPOINT ["/usr/bin/dotnet", "exec", "/var/task/bootstrap.dll"]
```
1. Installez l’[extension de l’outil global .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) d’Amazon.Lambda.Tools.
```
dotnet tool install -g Amazon.Lambda.Tools
```
Si Amazon.Lambda.Tools est déjà installé, assurez-vous que vous disposez de la dernière version.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Utilisez Amazon.Lambda.Tools pour créer l’image Docker, l’envoyer (push) vers un nouveau référentiel Amazon ECR, et déployer la fonction Lambda.
Pour `--function-role`, indiquez le nom du rôle, et non l’Amazon Resource Name (ARN), du [rôle d’exécution](lambda-intro-execution-role.md) de la fonction. Par exemple, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
Pour plus d'informations sur l'extension .NET CLI Amazon.Lambda.Tools, consultez le référentiel [AWS Extensions for .NET](https://github.com/aws/aws-extensions-for-dotnet-cli) CLI sur. GitHub
1. Invoquer la fonction.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
Si tout réussit, vous devez voir ce qui suit :
```
Payload:
"TESTING THE FUNCTION"
Log Tail:
START RequestId: id Version: $LATEST
END RequestId: id
REPORT RequestId: id Duration: 0.99 ms Billed Duration: 1 ms Memory Size: 256 MB Max Memory Used: 12 MB
```
1. Supprimez la fonction Lambda.
```
dotnet lambda delete-function MyFunction
```