

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 Go avec des archives de fichiers .zip
<a name="golang-package"></a>

Le code de votre AWS Lambda fonction se compose de scripts ou de programmes compilés et de leurs dépendances. Pour déployer votre code de fonction vers Lambda, vous utilisez un *package de déploiement*. Lambda prend en charge deux types de packages de déploiement : les images conteneurs et les archives de fichiers .zip. 

Cette page explique comment créer un fichier .zip en tant que package de déploiement pour le moteur d'exécution Go, puis utiliser le fichier .zip pour déployer votre code de fonction à AWS Lambda l'aide des AWS Management Console, AWS Command Line Interface (AWS CLI) et AWS Serverless Application Model (AWS SAM).

Notez que Lambda utilise les autorisations de fichiers POSIX. Ainsi, vous pourriez devoir [définir des autorisations pour le dossier du package de déploiement](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) avant de créer l’archive de fichiers .zip.

**Topics**
+ [Création d’un fichier .zip sur macOS et Linux](#golang-package-mac-linux)
+ [Création d’un fichier .zip sous Windows](#golang-package-windows)
+ [Création et mise à jour de fonctions Lambda Go à l’aide de fichiers .zip](#golang-package-create-function)

## Création d’un fichier .zip sur macOS et Linux
<a name="golang-package-mac-linux"></a>

Les étapes suivantes montrent comment compiler votre exécutable à l’aide de la commande `go build` et créer un package de déploiement de fichiers .zip pour Lambda. Avant de compiler votre code, assurez-vous d'avoir installé le package [lambda depuis](https://github.com/aws/aws-lambda-go/tree/master/lambda). GitHub Ce module fournit une implémentation de l’interface d’exécution, qui gère l’interaction entre Lambda et le code de votre fonction. Pour télécharger cette bibliothèque, exécutez la commande suivante.

```
go get github.com/aws/aws-lambda-go/lambda
```

Si votre fonction utilise le AWS SDK pour Go, téléchargez l'ensemble standard de modules du SDK, ainsi que tous les clients d'API de AWS service requis par votre application. Pour savoir comment installer le SDK pour Go, [consultez Getting Started with AWS SDK pour Go the](https://github.com/aws/aws-sdk-go-v2?tab=readme-ov-file#getting-started) V2.

### Utilisation de la famille d’environnement d’exécution fournie
<a name="golang-package-mac-linux-al2"></a>

Go est implémenté différemment des autres exécutions gérées. Go se compilant nativement en un binaire exécutable, il n’a pas besoin d’un environnement d’exécution dédié au langage. Utilisez un [environnement d’exécution réservé au système d’exploitation](runtimes-provided.md) (la famille d’environnement d’exécution `provided`) pour déployer les fonctions Go sur Lambda.

**Pour créer un package de déploiement .zip (macOS/Linux)**

1. Dans le répertoire du projet qui contient le fichier `main.go` de votre application, compilez votre exécutable. Notez ce qui suit :
   + L’exécutable doit être nommé `bootstrap`. Pour de plus amples informations, veuillez consulter [Convention de nommage du gestionnaire](golang-handler.md#golang-handler-naming).
   + Définissez l’[architecture de jeu d’instructions](foundation-arch.md) cible. Les environnements d’exécution réservés au système d’exploitation prennent en charge les architectures arm64 et x86\$164.
   + Vous pouvez utiliser la balise optionnelle `lambda.norpc` pour exclure le composant RPC (Remote Procedure Call) de la bibliothèque [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Le composant RPC n’est nécessaire que lorsque vous utilisez l’environnement d’exécution Go 1.x. L’exclusion du RPC réduit la taille du package de déploiement.

   Pour l’architecture arm64 :

   ```
   GOOS=linux GOARCH=arm64 go build -tags lambda.norpc -o bootstrap main.go
   ```

   Pour l’architecture x86\$164 :

   ```
   GOOS=linux GOARCH=amd64 go build -tags lambda.norpc -o bootstrap main.go
   ```

1. (Facultatif) Vous devrez peut-être compiler des packages avec `CGO_ENABLED=0` configuré sur Linux :

   ```
   GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o bootstrap -tags lambda.norpc main.go
   ```

   Cette commande crée un package binaire stable pour les versions de bibliothèque C standard (`libc`), qui peuvent être différentes sur Lambda et d’autres appareils.

1. Créez un package de déploiement en empaquetant l’exécutable dans un fichier .zip.

   ```
   zip myFunction.zip bootstrap
   ```
**Note**  
Le fichier `bootstrap` doit se situer à la racine du fichier .zip.

1. Créez la fonction . Notez ce qui suit :
   + Le binaire doit être nommé `bootstrap`, mais le nom du gestionnaire peut être quelconque. Pour de plus amples informations, veuillez consulter [Convention de nommage du gestionnaire](golang-handler.md#golang-handler-naming).
   + L’option `--architectures` n’est nécessaire que si vous utilisez arm64. La valeur par défaut est x86\$164.
   + Pour `--role`, spécifiez l’Amazon Resource Name (ARN) du [rôle d’exécution](lambda-intro-execution-role.md).

   ```
   aws lambda create-function --function-name myFunction \
   --runtime provided.al2023 --handler bootstrap \
   --architectures arm64 \
   --role arn:aws:iam::111122223333:role/lambda-ex \
   --zip-file fileb://myFunction.zip
   ```

## Création d’un fichier .zip sous Windows
<a name="golang-package-windows"></a>

Les étapes suivantes indiquent comment télécharger l'[build-lambda-zip](https://github.com/aws/aws-lambda-go/tree/main/cmd/build-lambda-zip)outil pour Windows depuis GitHub, compiler votre exécutable et créer un package de déploiement .zip.

**Note**  
Si vous ne l’avez pas déjà fait, vous devez installer [git](https://git-scm.com/), puis ajouter l’exécutable `git` à votre variable d’environnement Windows `%PATH%`.

Avant de compiler votre code, assurez-vous d'avoir installé la bibliothèque [Lambda depuis](https://github.com/aws/aws-lambda-go/tree/master/lambda). GitHub Pour télécharger cette bibliothèque, exécutez la commande suivante.

```
go get github.com/aws/aws-lambda-go/lambda
```

Si votre fonction utilise le AWS SDK pour Go, téléchargez l'ensemble standard de modules du SDK, ainsi que tous les clients d'API de AWS service requis par votre application. Pour savoir comment installer le SDK pour Go, [consultez Getting Started with AWS SDK pour Go the](https://aws.github.io/aws-sdk-go-v2/docs/getting-started/) V2.

### Utilisation de la famille d’environnement d’exécution fournie
<a name="golang-package-windows-al2"></a>

Go est implémenté différemment des autres exécutions gérées. Go se compilant nativement en un binaire exécutable, il n’a pas besoin d’un environnement d’exécution dédié au langage. Utilisez un [environnement d’exécution réservé au système d’exploitation](runtimes-provided.md) (la famille d’environnement d’exécution `provided`) pour déployer les fonctions Go sur Lambda.

**Pour créer un package de déploiement .zip (Windows)**

1. Téléchargez l'**build-lambda-zip**outil depuis GitHub.

   ```
   go install github.com/aws/aws-lambda-go/cmd/build-lambda-zip@latest
   ```

1. Utilisez l’outil de votre `GOPATH` pour créer un fichier .zip. Si vous disposez d’une installation de Go par défaut, l’outil est généralement dans `%USERPROFILE%\Go\bin`. Dans le cas contraire, accédez à l’endroit où vous avez installé l’environnement d’exécution Go et effectuez l’une des instructions suivantes :

------
#### [ cmd.exe ]

   Dans cmd.exe, exécutez l’une des commandes suivantes, en fonction de l’[architecture de jeu d’instructions](foundation-arch.md) cible. Les environnements d’exécution réservés au système d’exploitation prennent en charge les architectures arm64 et x86\$164.

   Vous pouvez utiliser la balise optionnelle `lambda.norpc` pour exclure le composant RPC (Remote Procedure Call) de la bibliothèque [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Le composant RPC n’est nécessaire que lorsque vous utilisez l’environnement d’exécution Go 1.x. L’exclusion du RPC réduit la taille du package de déploiement.

**Example — Pour l’architecture x86\$164**  

   ```
   set GOOS=linux
   set GOARCH=amd64
   set CGO_ENABLED=0
   go build -tags lambda.norpc -o bootstrap main.go
   %USERPROFILE%\Go\bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

**Example — Pour l’architecture arm64**  

   ```
   set GOOS=linux
   set GOARCH=arm64
   set CGO_ENABLED=0
   go build -tags lambda.norpc -o bootstrap main.go
   %USERPROFILE%\Go\bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

------
#### [ PowerShell ]

   Dans PowerShell, exécutez l'une des opérations suivantes, en fonction de l'[architecture de votre jeu d'instructions](foundation-arch.md) cible. Les environnements d’exécution réservés au système d’exploitation prennent en charge les architectures arm64 et x86\$164.

   Vous pouvez utiliser la balise optionnelle `lambda.norpc` pour exclure le composant RPC (Remote Procedure Call) de la bibliothèque [lambda](https://github.com/aws/aws-lambda-go/tree/master/lambda). Le composant RPC n’est nécessaire que lorsque vous utilisez l’environnement d’exécution Go 1.x. L’exclusion du RPC réduit la taille du package de déploiement.

   Pour l’architecture x86\$164 :

   ```
   $env:GOOS = "linux"
   $env:GOARCH = "amd64"
   $env:CGO_ENABLED = "0"
   go build -tags lambda.norpc -o bootstrap main.go
   ~\Go\Bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

   Pour l’architecture arm64 :

   ```
   $env:GOOS = "linux"
   $env:GOARCH = "arm64"
   $env:CGO_ENABLED = "0"
   go build -tags lambda.norpc -o bootstrap main.go
   ~\Go\Bin\build-lambda-zip.exe -o myFunction.zip bootstrap
   ```

------

1. Créez la fonction . Notez ce qui suit :
   + Le binaire doit être nommé `bootstrap`, mais le nom du gestionnaire peut être quelconque. Pour de plus amples informations, veuillez consulter [Convention de nommage du gestionnaire](golang-handler.md#golang-handler-naming).
   + L’option `--architectures` n’est nécessaire que si vous utilisez arm64. La valeur par défaut est x86\$164.
   + Pour `--role`, spécifiez l’Amazon Resource Name (ARN) du [rôle d’exécution](lambda-intro-execution-role.md).

   ```
   aws lambda create-function --function-name myFunction \
   --runtime provided.al2023 --handler bootstrap \
   --architectures arm64 \
   --role arn:aws:iam::111122223333:role/lambda-ex \
   --zip-file fileb://myFunction.zip
   ```

## Création et mise à jour de fonctions Lambda Go à l’aide de fichiers .zip
<a name="golang-package-create-function"></a>

 Une fois que vous avez créé votre package de déploiement .zip, vous pouvez l’utiliser pour créer une nouvelle fonction Lambda ou mettre à jour une fonction Lambda existante. Vous pouvez déployer votre package .zip à l'aide de la console Lambda, de l'API Lambda et AWS Command Line Interface de l'API Lambda. Vous pouvez également créer et mettre à jour des fonctions Lambda à l’aide de l’ AWS Serverless Application Model (AWS SAM) et de CloudFormation. 

La taille maximale d’un package de déploiement .zip pour Lambda est de 250 Mo (décompressé). Notez que cette limite s’applique à la taille combinée de tous les fichiers que vous chargez, y compris les couches Lambda.

Le runtime Lambda a besoin d’une autorisation pour lire les fichiers de votre package de déploiement. Dans la notation octale des autorisations Linux, Lambda a besoin de 644 autorisations pour les fichiers non exécutables (rw-r--r--) et de 755 autorisations () pour les répertoires et les fichiers exécutables. rwxr-xr-x

Sous Linux et macOS, utilisez la commande `chmod` pour modifier les autorisations de fichiers sur les fichiers et les répertoires de votre package de déploiement. Par exemple, pour octroyer à un fichier non exécutable les autorisations correctes, exécutez la commande suivante.

```
chmod 644 <filepath>
```

Pour modifier les autorisations relatives aux fichiers dans Windows, voir [Définir, afficher, modifier ou supprimer des autorisations sur un objet](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) dans la documentation Microsoft Windows.

**Note**  
Si vous n'accordez pas à Lambda les autorisations nécessaires pour accéder aux répertoires de votre package de déploiement, Lambda définit les autorisations pour ces répertoires sur 755 (). rwxr-xr-x

### Création et mise à jour de fonctions avec des fichiers .zip à l’aide de la console
<a name="golang-package-create-console"></a>

 Pour créer une nouvelle fonction, vous devez d’abord créer la fonction dans la console, puis charger votre archive .zip. Pour mettre à jour une fonction existante, ouvrez la page de votre fonction, puis suivez la même procédure pour ajouter votre fichier .zip mis à jour. 

 Si votre fichier .zip fait moins de 50 Mo, vous pouvez créer ou mettre à jour une fonction en chargeant le fichier directement à partir de votre ordinateur local. Pour les fichiers .zip de plus de 50 Mo, vous devez d’abord charger votre package dans un compartiment Amazon S3. Pour savoir comment charger un fichier dans un compartiment Amazon S3 à l'aide du AWS Management Console, consultez [Getting started with Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). Pour télécharger des fichiers à l'aide de AWS CLI, voir [Déplacer des objets](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) dans le *guide de AWS CLI l'utilisateur*. 

**Note**  
Vous ne pouvez pas convertir une fonction d’image de conteneur existante pour utiliser une archive .zip. Vous devez créer une nouvelle fonction.

**Pour créer une nouvelle fonction (console)**

1. Ouvrez la [page Fonctions](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda et choisissez **Créer une fonction**.

1. Choisissez **Créer à partir de zéro**.

1. Sous **Informations de base**, procédez comme suit :

   1. Pour **Nom de la fonction**, saisissez le nom de la fonction.

   1. Dans **Runtime (Exécution)**, choisissez `provided.al2023`.

1. (Facultatif) Sous **Permissions (Autorisations)**, développez **Change default execution role (Modifier le rôle d’exécution par défaut)**. Vous pouvez créer un **rôle d’exécution** ou en utiliser un existant.

1. Choisissez **Créer une fonction**. Lambda crée une fonction de base « Hello world » à l’aide de l’exécution de votre choix.

**Pour charger une archive .zip à partir de votre ordinateur local (console)**

1. Sur la [page Fonctions](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda, choisissez la fonction pour laquelle vous souhaitez charger le fichier .zip.

1. Sélectionnez l’onglet **Code**.

1. Dans le volet **Source du code**, choisissez **Charger à partir de**.

1. Choisissez **Fichier .zip**.

1. Pour charger un fichier .zip, procédez comme suit :

   1. Sélectionnez **Charger**, puis choisissez votre fichier .zip dans le sélecteur de fichiers.

   1. Choisissez **Ouvrir**.

   1. Choisissez **Enregistrer**.

**Pour charger une archive .zip depuis un compartiment Amazon S3 (console)**

1. Sur la [page Fonctions](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda, choisissez la fonction pour laquelle vous souhaitez charger un nouveau fichier .zip.

1. Sélectionnez l’onglet **Code**.

1. Dans le volet **Source du code**, choisissez **Charger à partir de**.

1. Choisissez l’**emplacement Amazon S3**.

1. Collez l’URL du lien Amazon S3 de votre fichier .zip et choisissez **Enregistrer**.

### Création et mise à jour de fonctions avec des fichiers .zip à l'aide du AWS CLI
<a name="golang-package-create-cli"></a>

 Vous pouvez utiliser l’[AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) pour créer une nouvelle fonction ou pour mettre à jour une fonction existante à l’aide d’un fichier .zip. Utilisez la [fonction de création](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) et [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html)les commandes pour déployer votre package .zip. Si votre fichier .zip est inférieur à 50 Mo, vous pouvez charger le package .zip à partir d’un emplacement de fichier sur votre machine de génération locale. Pour les fichiers plus volumineux, vous devez charger votre package .zip à partir d’un compartiment Amazon S3. Pour savoir comment charger un fichier dans un compartiment Amazon S3 à l'aide du AWS CLI, consultez la section [Déplacer des objets](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) dans le *guide de AWS CLI l'utilisateur*. 

**Note**  
Si vous chargez votre fichier .zip depuis un compartiment Amazon S3 à l'aide de AWS CLI, le compartiment doit se trouver au même endroit Région AWS que votre fonction.

 Pour créer une nouvelle fonction à l'aide d'un fichier .zip avec le AWS CLI, vous devez spécifier les éléments suivants : 
+ Le nom de votre fonction (`--function-name`)
+ L’exécution de votre fonction (`--runtime`)
+ L’Amazon Resource Name (ARN) du [rôle d’exécution](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) de votre fonction (`--role`)
+ Le nom de la méthode du gestionnaire dans votre code de fonction (`--handler`)

 Vous devez également indiquer l’emplacement de votre fichier .zip. Si votre fichier .zip se trouve dans un dossier sur votre machine de génération locale, utilisez l’option `--zip-file` pour spécifier le chemin d’accès du fichier, comme le montre l’exemple de commande suivant. 

```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```

 Pour spécifier l’emplacement du fichier .zip dans un compartiment Amazon S3, utilisez l’option `--code` comme le montre l’exemple de commande suivant. Vous devez uniquement utiliser le paramètre `S3ObjectVersion` pour les objets soumis à la gestion des versions. 

```
aws lambda create-function --function-name myFunction \
--runtime provided.al2023 --handler bootstrap \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```

 Pour mettre à jour une fonction existante à l’aide de l’interface de ligne de commande, vous devez spécifier le nom de votre fonction à l’aide du paramètre `--function-name`. Vous devez également spécifier l’emplacement du fichier .zip que vous souhaitez utiliser pour mettre à jour votre code de fonction. Si votre fichier .zip se trouve dans un dossier sur votre machine de génération locale, utilisez l’option `--zip-file` pour spécifier le chemin d’accès du fichier, comme le montre l’exemple de commande suivant. 

```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```

 Pour spécifier l’emplacement du fichier .zip dans un compartiment Amazon S3, utilisez les options `--s3-bucket` et `--s3-key` comme le montre l’exemple de commande suivant. Vous devez uniquement utiliser le paramètre `--s3-object-version` pour les objets soumis à la gestion des versions. 

```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```

### Création et mise à jour de fonctions avec des fichiers .zip à l’aide de l’API Lambda
<a name="golang-package-create-api"></a>

 Pour créer et mettre à jour des fonctions à l’aide d’une archive de fichiers .zip, utilisez les opérations d’API suivantes : 
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)

### Création et mise à jour de fonctions avec des fichiers .zip à l'aide de AWS SAM
<a name="golang-package-create-sam"></a>

 The AWS Serverless Application Model (AWS SAM) est une boîte à outils qui permet de rationaliser le processus de création et d'exécution d'applications sans serveur sur AWS. Vous définissez les ressources de votre application dans un modèle YAML ou JSON et vous utilisez l'interface de ligne de AWS SAM commande (AWS SAM CLI) pour créer, empaqueter et déployer vos applications. Lorsque vous créez une fonction Lambda à partir d'un AWS SAM modèle, elle crée AWS SAM automatiquement un package de déploiement ou une image de conteneur .zip avec le code de votre fonction et les dépendances que vous spécifiez. Pour en savoir plus sur l'utilisation des fonctions Lambda AWS SAM pour créer et déployer des fonctions Lambda, consultez [Getting started with AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) dans le Guide du *AWS Serverless Application Model développeur*.

Vous pouvez également l'utiliser AWS SAM pour créer une fonction Lambda à l'aide d'une archive de fichiers .zip existante. Pour créer une fonction Lambda à l'aide de AWS SAM, vous pouvez enregistrer votre fichier .zip dans un compartiment Amazon S3 ou dans un dossier local sur votre machine de génération. Pour savoir comment charger un fichier dans un compartiment Amazon S3 à l'aide du AWS CLI, consultez la section [Déplacer des objets](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) dans le *guide de AWS CLI l'utilisateur*. 

 Dans votre AWS SAM modèle, la `AWS::Serverless::Function` ressource spécifie votre fonction Lambda. Dans cette ressource, définissez les propriétés suivantes pour créer une fonction à l’aide d’une archive de fichiers .zip : 
+ `PackageType` : défini sur `Zip`
+ `CodeUri`- défini sur l'URI Amazon S3, le chemin d'accès au dossier local ou à l'[FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)objet du code de fonction
+ `Runtime` : défini sur votre exécution choisie

 Ainsi AWS SAM, si votre fichier .zip est supérieur à 50 Mo, vous n'avez pas besoin de le télécharger au préalable dans un compartiment Amazon S3. AWS SAM peut télécharger des packages .zip jusqu'à la taille maximale autorisée de 250 Mo (décompressés) à partir d'un emplacement sur votre machine de compilation locale. 

 Pour en savoir plus sur le déploiement de fonctions à l'aide d'un fichier .zip dans AWS SAM, consultez [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)le *manuel du AWS SAM développeur*. 

**Exemple : utilisation AWS SAM pour créer une fonction Go avec provided.al2023**

1. Créez un AWS SAM modèle avec les propriétés suivantes :
   + **BuildMethod**: Spécifie le compilateur de votre application. Utilisez `go1.x`.
   + **Runtime** : utilisez `provided.al2023`.
   + **CodeUri**: Entrez le chemin d'accès à votre code.
   + **Architectures** : Utilisez `[arm64]` pour l’architecture arm64. Pour l’architecture x86\$164, utilisez `[amd64]` ou supprimez la propriété `Architectures`.  
**Example template.yaml**  

   ```
   AWSTemplateFormatVersion: '2010-09-09'
   Transform: 'AWS::Serverless-2016-10-31'
   Resources:
     HelloWorldFunction:
       Type: AWS::Serverless::Function
       Metadata:
         BuildMethod: go1.x
       Properties:
         CodeUri: hello-world/ # folder where your main program resides
         Handler: bootstrap
         Runtime: provided.al2023
         Architectures: [arm64]
   ```

1. Utilisez la commande [sam build](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html) pour compiler l’exécutable.

   ```
   sam build
   ```

1. Utilisez la commande [sam deploy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) pour déployer la fonction vers Lambda.

   ```
   sam deploy --guided
   ```

### Création et mise à jour de fonctions avec des fichiers .zip à l'aide de CloudFormation
<a name="golang-package-create-cfn"></a>

 Vous pouvez l'utiliser CloudFormation pour créer une fonction Lambda à l'aide d'une archive de fichiers .zip. Pour créer une fonction Lambda à partir d’un fichier .zip, vous devez d’abord charger votre fichier dans un compartiment Amazon S3. Pour savoir comment charger un fichier dans un compartiment Amazon S3 à l'aide du AWS CLI, consultez la section [Déplacer des objets](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) dans le *guide de AWS CLI l'utilisateur.*

Dans votre CloudFormation modèle, la `AWS::Lambda::Function` ressource spécifie votre fonction Lambda. Dans cette ressource, définissez les propriétés suivantes pour créer une fonction à l’aide d’une archive de fichiers .zip :
+ `PackageType` : défini sur `Zip`
+ `Code` : saisissez le nom du compartiment Amazon S3 et le nom du fichier .zip dans les champs `S3Bucket` et `S3Key`
+ `Runtime` : défini sur votre exécution choisie

 Le fichier .zip CloudFormation généré ne peut pas dépasser 4 Mo. Pour en savoir plus sur le déploiement de fonctions à l'aide d'un fichier .zip dans CloudFormation, consultez [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)le *Guide de l'CloudFormation utilisateur*. 