Table Of Content

AWS Lambda Guide du développeur AWS Lambda Guide du développeur AWS Lambda: Guide du développeur Copyright © 2022 Amazon Web Services, Inc. and/or its affiliates. All rights reserved. Les marques commerciales et la présentation commerciale d'Amazon ne peuvent pas être utilisées en relation avec un produit ou un service extérieur à Amazon, d'une manière susceptible d'entraîner une confusion chez les clients, ou d'une manière qui dénigre ou discrédite Amazon. Toutes les autres marques commerciales qui ne sont pas la propriété d'Amazon appartiennent à leurs propriétaires respectifs, qui peuvent ou non être affiliés, connectés à ou sponsorisés par Amazon. AWS Lambda Guide du développeur Table of Contents Qu'est-ce que AWS Lambda ?.............................................................................................................. 1 Dans quels cas est-il conseillé d'utiliser Lambda ?........................................................................... 1 Fonctionnalités de Lambda.......................................................................................................... 2 Démarrage avec Lambda............................................................................................................. 3 Services connexes...................................................................................................................... 3 Accès à Lambda........................................................................................................................ 4 Tarification pour Lambda............................................................................................................. 4 Prérequis........................................................................................................................................... 5 AWSCompte.............................................................................................................................. 5 AWS CLI................................................................................................................................... 5 AWS SAM................................................................................................................................. 5 AWS SAM CLI........................................................................................................................... 6 Outils pour les images de conteneur............................................................................................. 6 Outils de création de code........................................................................................................... 6 Mise en route.................................................................................................................................... 8 Créer une fonction Lambda à l'aide de la console........................................................................... 8 Créer la fonction................................................................................................................. 8 Appeler la fonction Lambda.................................................................................................. 9 Nettoyage........................................................................................................................ 10 Principes de base de Lambda............................................................................................................ 11 Concepts................................................................................................................................. 12 Fonction.......................................................................................................................... 12 Déclencheur..................................................................................................................... 12 Événement....................................................................................................................... 12 Environnement d’exécution................................................................................................. 13 Architecture de l’ensemble des instructions........................................................................... 13 Package de déploiement.................................................................................................... 13 Exécution......................................................................................................................... 13 Couche............................................................................................................................ 14 Extension......................................................................................................................... 14 Concurrency..................................................................................................................... 14 Qualificateur..................................................................................................................... 15 Destination (Destination).................................................................................................... 15 Fonctions................................................................................................................................. 16 Mise à l'échelle................................................................................................................ 16 Contrôles de simultanéité................................................................................................... 17 URL de fonctions.............................................................................................................. 18 Appel asynchrone............................................................................................................. 18 Mappages de source d'événement...................................................................................... 19 Destinations..................................................................................................................... 20 Plans de fonction.............................................................................................................. 21 Outils de test et de déploiement.......................................................................................... 21 Modèles d'application........................................................................................................ 22 Modèle de programmation.......................................................................................................... 23 Architectures............................................................................................................................ 24 Avantages liés à l’utilisation de l’architecture arm64............................................................... 24 Migration de la fonction vers l’architecture arm64................................................................... 24 Compatibilité des codes de fonction avec l’architecture arm64.................................................. 25 Étapes de migration suggérées........................................................................................... 25 Configuration de l’architecture de l’ensemble des instructions.................................................. 26 Réseaux.................................................................................................................................. 27 Eléments réseau VPC....................................................................................................... 27 Connexion des fonctions Lambda à votre VPC...................................................................... 28 ENI Hyperplane Lambda.................................................................................................... 28 iii AWS Lambda Guide du développeur Connexions...................................................................................................................... 29 Sécurité........................................................................................................................... 30 Observabilité.................................................................................................................... 30 Mise à l'échelle de fonction........................................................................................................ 31 Packages de déploiement.......................................................................................................... 36 Images de conteneur......................................................................................................... 36 Archives de fichiers .zip..................................................................................................... 36 Couches.......................................................................................................................... 37 Utilisation d'autres services AWS........................................................................................ 38 Console Lambda....................................................................................................................... 39 Applications...................................................................................................................... 39 Fonctions......................................................................................................................... 39 Signature de code............................................................................................................. 39 Couches.......................................................................................................................... 39 Éditer du code à l'aide de l'éditeur de la console................................................................... 39 CLI Lambda............................................................................................................................. 46 Prérequis......................................................................................................................... 46 Créer le rôle d'exécution.................................................................................................... 46 Créer la fonction............................................................................................................... 47 Mettre à jour la fonction..................................................................................................... 50 Répertorier les fonctions Lambda dans votre compte.............................................................. 50 Récupérer une fonction Lambda......................................................................................... 51 Nettoyage........................................................................................................................ 51 Autorisations.................................................................................................................................... 52 Rôle d'exécution....................................................................................................................... 53 Création d'un rôle d'exécution dans la console IAM................................................................ 53 Accorder un accès assorti d'un privilège minimum à votre rôle d'exécution Lambda...................... 54 Gestion des rôles avec l'API IAM........................................................................................ 54 Durée de session pour les informations d'identification de sécurité provisoires............................ 55 Stratégies gérées par AWS pour les fonctions Lambda........................................................... 55 Utilisation des informations d'identification d'un environnement d'exécution Lambda..................... 57 Stratégies utilisateur.................................................................................................................. 60 Développement des fonctions............................................................................................. 60 Développement et utilisation des couches............................................................................. 63 Rôles entre comptes......................................................................................................... 64 Clés de condition pour les paramètres du VPC.................................................................... 64 Contrôler l'accès à l'aide de balises............................................................................................. 65 Prérequis......................................................................................................................... 65 Étape 1 : Exiger des balises............................................................................................... 65 Étape 2 : Contrôler les actions à l'aide de balises.................................................................. 66 Étape 3 : Accorder des permissions de liste.......................................................................... 66 Étape 4 : accorder des autorisations IAM.............................................................................. 67 Étape 5 : Création du rôle IAM............................................................................................ 67 Étape 6 : Création d'un utilisateur IAM.................................................................................. 68 Étape 7 : Tester les autorisations........................................................................................ 68 Politiques basées sur les ressources........................................................................................... 69 Octroi à la fonction de l'accès aux services AWS................................................................... 70 Octroi de l'accès à la fonction à une organisation.................................................................. 71 Octroi de l'accès à la fonction à d'autres comptes.................................................................. 72 Octroi de l'accès de la couche à d'autres comptes................................................................. 73 Nettoyage des stratégies basées sur les ressources............................................................... 74 Ressources et conditions........................................................................................................... 75 Conditions de stratégie...................................................................................................... 76 Noms de ressource de fonction.......................................................................................... 76 Actions de fonction........................................................................................................... 78 Actions de mappage de la source d'événement..................................................................... 80 Actions de couche............................................................................................................ 80 iv AWS Lambda Guide du développeur Limites d'autorisations................................................................................................................ 82 Environnements d’exécution (runtimes) Lambda.................................................................................... 84 Politique d'obsolescence de l'exécution........................................................................................ 85 Modifications du runtime............................................................................................................ 88 Variables d'environnement spécifiques à un langage.............................................................. 88 Scripts encapsuleurs......................................................................................................... 90 Environnements d’exécution personnalisés................................................................................... 93 Utilisation d’un environnement d’exécution personnalisé.......................................................... 93 Création d’un environnement d’exécution personnalisé........................................................... 93 Didacticiel – Runtime personnalisé.............................................................................................. 96 Prérequis......................................................................................................................... 96 Créer une fonction............................................................................................................ 96 Créer une couche............................................................................................................. 98 Mettre à jour la fonction..................................................................................................... 99 Mettre à jour le runtime.................................................................................................... 100 Partager la couche.......................................................................................................... 100 Nettoyage...................................................................................................................... 101 Vectorisation AVX2.................................................................................................................. 102 Compilation à partir d’un fichier source............................................................................... 102 Activation d'AVX2 pour Intel MKL...................................................................................... 102 Prise en charge d'AVX2 dans d'autres langues.................................................................... 102 Environnement d’exécution............................................................................................................... 104 API d’extensions..................................................................................................................... 105 Cycle de vie d’un environnement d’exécution Lambda.......................................................... 106 Référence d’API d’extensions............................................................................................ 115 API de runtime....................................................................................................................... 120 Appel suivant.................................................................................................................. 120 Réponse d'appel............................................................................................................. 121 Erreur d'initialisation......................................................................................................... 121 Erreur d'appel................................................................................................................. 123 API Logs................................................................................................................................ 125 S'abonner pour recevoir des journaux................................................................................ 126 Utilisation de la mémoire.................................................................................................. 126 Protocoles de destination................................................................................................. 126 Configuration de mise en mémoire tampon......................................................................... 126 Exemple d'abonnement.................................................................................................... 127 Exemple de code pour l'API Logs ...................................................................................... 128 Référence d'API Logs...................................................................................................... 128 Messages de journaux..................................................................................................... 129 Partenaires des extensions....................................................................................................... 132 Extensions AWS gérées................................................................................................... 133 Cycle de vie de l’environnement d’exécution............................................................................... 133 Phase d’initialisation........................................................................................................ 134 Phase d’appel................................................................................................................. 109 Phase d’arrêt.................................................................................................................. 111 Déploiement des fonctions................................................................................................................ 136 Archives de fichiers .zip............................................................................................................ 136 Images de conteneur............................................................................................................... 136 Archives de fichiers .zip............................................................................................................ 138 Création de la fonction..................................................................................................... 138 Utilisation de l’éditeur de code de la console....................................................................... 139 Mise à jour du code de fonction ........................................................................................ 139 Modification de l'exécution ou la version d'exécution............................................................. 140 Modification de l'architecture............................................................................................. 140 Utilisation de l’API Lambda............................................................................................... 141 AWS CloudFormation...................................................................................................... 141 Images de conteneur............................................................................................................... 142 v AWS Lambda Guide du développeur Prérequis....................................................................................................................... 142 Autorisations................................................................................................................... 143 Création de la fonction..................................................................................................... 144 Test de la fonction.......................................................................................................... 146 Remplacement des paramètres de conteneur...................................................................... 147 Mise à jour du code de fonction ........................................................................................ 147 Utilisation de l’API Lambda............................................................................................... 148 AWS CloudFormation...................................................................................................... 149 Création d'images de conteneur........................................................................................................ 150 Images de base pour Lambda.................................................................................................. 151 Images de base AWS pour Lambda.................................................................................. 151 Images de base pour les environnements d’exécution personnalisés....................................... 151 Clients d’interface d’exécution........................................................................................... 152 Émulateur d’interface d’exécution....................................................................................... 152 Test des images...................................................................................................................... 153 Conseils d’utilisation du RIE............................................................................................. 153 Variables d’environnement................................................................................................ 153 Test d’une image avec RIE inclus dans l’image................................................................... 154 Intégration du RIE à votre image de base........................................................................... 154 Test d’une image sans ajouter de RIE à l’image.................................................................. 155 Prérequis............................................................................................................................... 156 Types d’images....................................................................................................................... 156 Outils de conteneur................................................................................................................. 157 Paramètres d’images de conteneur............................................................................................ 157 Création d'images à partir d'images de base AWS....................................................................... 157 Création d'images à partir d'autres images de base...................................................................... 159 Charger l'image dans le référentiel Amazon ECR......................................................................... 161 Création d’une image à l’aide de la boîte à outils AWS SAM.......................................................... 161 Configuration des fonctions............................................................................................................... 162 Création de couches................................................................................................................ 163 Création du contenu de la couche..................................................................................... 163 Compilation de l’archive de fichier .zip pour votre couche...................................................... 163 Inclusion de dépendances de bibliothèques dans une couche................................................ 164 Instructions spécifiques du langage.................................................................................... 165 Création d’une couche..................................................................................................... 166 Suppression d’une version de couche................................................................................ 167 Configuration des autorisations de couche.......................................................................... 167 Utilisation de AWS CloudFormation avec des couches.......................................................... 168 Configuration des options de fonction......................................................................................... 169 Versions de la fonction.................................................................................................... 169 Utilisation de la présentation de la fonction......................................................................... 169 Configuration des fonctions (console)................................................................................. 170 Configuration de fonctions (API)........................................................................................ 141 Configuration de la mémoire d'une fonction (console)........................................................... 171 Configuration du magasin éphémère (console).................................................................... 172 Acceptation des recommandations relatives à la mémoire d'une fonction (console)..................... 172 Configuration des déclencheurs (console)........................................................................... 173 Tests des fonctions (console)............................................................................................ 173 Variables d’environnement........................................................................................................ 174 Configuration des variables d’environnement....................................................................... 174 Configuration de variables d’environnement avec l’API.......................................................... 175 Exemple de scénario pour les variables d’environnement...................................................... 176 Récupérer les variables d’environnement............................................................................ 176 Variables d’environnement d’exécution définies.................................................................... 177 Sécurisation des variables d’environnement........................................................................ 178 Exemples de code et de modèles ...................................................................................... 180 Versions................................................................................................................................ 182 vi AWS Lambda Guide du développeur Création de versions de fonction....................................................................................... 182 Gestion des versions avec l'API Lambda............................................................................ 182 Utilisation des versions.................................................................................................... 183 Octroi d'autorisations....................................................................................................... 183 Alias...................................................................................................................................... 184 Création d'un alias de fonction (console)............................................................................. 184 Gestion des alias avec l'API Lambda................................................................................. 184 Utilisation des alias......................................................................................................... 185 Stratégies basées sur une ressource................................................................................. 185 Configuration du routage d’alias........................................................................................ 185 Gestion des fonctions...................................................................................................................... 188 Simultanéité réservée.............................................................................................................. 189 Configuration de la simultanéité réservée............................................................................ 189 Configuration de la simultanéité avec l’API Lambda.............................................................. 191 Simultanéité provisionnée......................................................................................................... 192 Configuration de la simultanéité provisionnée...................................................................... 192 Optimisation de la latence avec la simultanéité provisionnée.................................................. 194 Gestion de la simultanéité provisionnée avec Application Auto Scaling..................................... 196 Réseaux................................................................................................................................ 200 Gestion des connexions VPC............................................................................................ 200 Rôle d’exécution et autorisations utilisateur......................................................................... 201 Configuration de l’accès VPC (console).............................................................................. 201 Configuration de l’accès VPC (API).................................................................................... 202 Utilisation des clés de condition IAM pour les paramètres du VPC.......................................... 203 Accès à Internet et aux services pour des fonctions connectées à un VPC............................... 206 Didacticiels de VPC......................................................................................................... 206 Exemples de configurations de VPC.................................................................................. 207 Points de terminaison de VPC d'interface................................................................................... 208 Considérations relatives aux points de terminaison d'interface Lambda.................................... 208 Création d'un point de terminaison d'interface pour Lambda................................................... 209 Création d'une stratégie de point de terminaison d'interface pour Lambda................................. 210 Base de données.................................................................................................................... 211 Création d'un proxy de base de données (console).............................................................. 211 Utilisation des autorisations de la fonction pour l'authentification............................................. 212 Exemple d'application...................................................................................................... 212 Système de fichiers................................................................................................................. 216 Rôle d'exécution et autorisations utilisateur......................................................................... 216 Configuration d'un système de fichiers et d'un point d'accès................................................... 216 Connexion à un système de fichiers (console)..................................................................... 217 Configuration de l'accès au système de fichiers avec l'API Lambda......................................... 218 AWS CloudFormation et AWS SAM................................................................................... 219 Exemples d'applications................................................................................................... 220 Signature de code................................................................................................................... 221 Validation de signature..................................................................................................... 222 Conditions préalables à la configuration.............................................................................. 222 Création de configurations de signature de code.................................................................. 222 Mise à jour d'une configuration de signature de code............................................................ 223 Suppression d'une configuration de signature de code.......................................................... 223 Activation de la signature de code pour une fonction............................................................ 223 Configuration des stratégies IAM....................................................................................... 224 Configuration de la signature de code avec l'API Lambda...................................................... 225 Étiquettes............................................................................................................................... 226 Autorisations................................................................................................................... 226 Utilisation des étiquettes avec la console............................................................................ 226 Utilisation des balises avec AWS CLI................................................................................. 228 Exigences relatives aux balises......................................................................................... 229 Utilisation des couches............................................................................................................ 230 vii AWS Lambda Guide du développeur Configuration de fonctions pour utiliser les couches.............................................................. 230 Accès au contenu de la couche à partir de la fonction.......................................................... 233 Recherche d'informations sur la couche.............................................................................. 233 Ajout d'autorisations de couche......................................................................................... 234 Utilisation de AWS SAM pour ajouter une couche à une fonction............................................ 168 Exemples d'applications................................................................................................... 235 Appel de fonctions.......................................................................................................................... 236 Appel synchrone..................................................................................................................... 238 Appel asynchrone................................................................................................................... 241 Description de la gestion des appels asynchrones par Lambda............................................... 241 Configuration de la gestion des erreurs pour les appels asynchrones....................................... 243 Configuration des destinations pour les appels asynchrones.................................................. 243 API de configuration d'appel asynchrone............................................................................ 246 Files d'attente de lettres mortes......................................................................................... 247 Mappage de source d’événement.............................................................................................. 250 Comportement de traitement par lots................................................................................. 251 Filtrage des événements.......................................................................................................... 255 Notions de base du filtrage d'événements........................................................................... 255 Syntaxe des règles de filtrage........................................................................................... 256 Exemples de filtrage........................................................................................................ 257 Attacher des critères de filtre à un mappage de sources d'événements (console)....................... 259 Attacher des critères de filtre à un mappage de sources d'événements (AWS CLI)..................... 260 Filtrage correct des messages Amazon SQS....................................................................... 260 Filtrage correct des messages Kinesis et DynamoDB............................................................ 261 États des fonctions.................................................................................................................. 263 États de la fonction lors de la mise à jour........................................................................... 263 Gestion des erreurs................................................................................................................. 265 Tests des fonctions................................................................................................................. 267 Événements de test privés............................................................................................... 267 Événements de test partageables...................................................................................... 267 Appel de fonctions avec des événements de test................................................................. 268 Suppression des schémas d’événements de test partageables............................................... 269 Utilisation des extensions......................................................................................................... 270 Environnement d'exécution............................................................................................... 270 Impact sur les performances et les ressources.................................................................... 271 Autorisations................................................................................................................... 271 Configuration des extensions (archive de fichiers .zip)........................................................... 271 Utilisation des extensions dans les images de conteneur....................................................... 272 Étapes suivantes............................................................................................................. 272 Appel des fonctions définies en tant qu'images de conteneur......................................................... 273 Cycle de vie des fonctions................................................................................................ 273 Appel de la fonction........................................................................................................ 273 Sécurité de l'image.......................................................................................................... 273 URL de fonctions............................................................................................................................ 274 Création et gestion des URL de fonctions................................................................................... 275 Création d’une URL de fonction (console)........................................................................... 275 Création d'URL de fonction (AWS CLI)............................................................................... 276 Ajout d'une URL de fonction à un modèle CloudFormation..................................................... 277 Partage des ressources cross-origin (CORS)....................................................................... 278 Limitation des URL de fonctions........................................................................................ 279 Désactivation des URL de fonctions................................................................................... 279 Suppression d'URL de fonction......................................................................................... 279 Modèle de sécurité et d'authentification...................................................................................... 280 Utilisation du type d’authentification AWS_IAM ...................................................................... 280 Utilisation du type d’authentification NONE ........................................................................... 282 Gouvernance et contrôle d'accès....................................................................................... 283 Appel d’URL de fonctions......................................................................................................... 286 viii AWS Lambda Guide du développeur Principes de base de l'appel d'une URL de fonction............................................................. 286 Charges utiles de demandes et de réponses....................................................................... 287 URL de fonctions de surveillance.............................................................................................. 294 URL de fonctions de surveillance avec CloudTrail................................................................ 294 Métriques CloudWatch pour les URL de fonctions................................................................ 294 Didacticiel : création d'une fonction avec une URL de fonction........................................................ 296 Prérequis....................................................................................................................... 296 Créer un rôle d'exécution................................................................................................. 296 Création d'une fonction Lambda avec une URL de fonction (archive de fichier ZIP).................... 297 Test du point de terminaison d'URL de fonction................................................................... 297 Création d'une fonction Lambda avec une URL de fonction (CloudFormation)........................... 298 Créer une fonction Lambda avec une URL de fonction (AWS SAM)........................................ 298 Nettoyage de vos ressources............................................................................................ 299 Utilisation de Node.js....................................................................................................................... 300 Initialisation de Node.js............................................................................................................ 302 Désignation d’un gestionnaire de fonctions en tant que module ES......................................... 302 Gestionnaire........................................................................................................................... 304 Gestionnaires asynchrones............................................................................................... 304 Gestionnaires non asynchrones......................................................................................... 305 Déploiement d'archives de fichiers .zip....................................................................................... 307 Prerequisites.................................................................................................................. 307 Mise à jour d'une fonction sans dépendances...................................................................... 308 Mise à jour d'une fonction avec dépendances supplémentaires............................................... 308 Déploiement d’images de conteneur.......................................................................................... 310 Images de base AWS pour Node.js................................................................................... 310 Utilisation d’une image de base Node.js............................................................................. 311 Clients d’interface d’environnement d’exécution Node.js........................................................ 311 Déployer l’image de conteneur.......................................................................................... 311 Contexte................................................................................................................................ 312 Journalisation......................................................................................................................... 314 Création d'une fonction qui renvoie des journaux................................................................. 314 Utilisation de la console Lambda....................................................................................... 315 Utilisation de la console CloudWatch.................................................................................. 315 Utilisation de AWS Command Line Interface (AWS CLI)........................................................ 316 Suppression de journaux.................................................................................................. 318 Erreurs.................................................................................................................................. 319 Syntaxe......................................................................................................................... 319 Fonctionnement.............................................................................................................. 319 Utilisation de la console Lambda....................................................................................... 320 Utilisation de AWS Command Line Interface (AWS CLI)........................................................ 320 Gestion des erreurs dans d’autres services AWS................................................................. 321 Quelle est la prochaine étape ? ......................................................................................... 322 Tracing.................................................................................................................................. 323 Utilisation d’ADOT pour instrumenter vos fonctions Node.js.................................................... 323 Utilisation du kit SDK X-Ray pour instrumenter vos fonctions Node.js...................................... 324 Activation du suivi avec la console Lambda......................................................................... 325 Activation du suivi avec l’API Lambda................................................................................ 325 Activation du suivi avec AWS CloudFormation..................................................................... 325 Interprétation d'un suivi X-Ray........................................................................................... 326 Stockage des dépendances d’exécution dans une couche (kit SDK X-Ray)............................... 328 Utilisation avec TypeScript................................................................................................................ 329 Environnement de développement............................................................................................. 329 Gestionnaire........................................................................................................................... 331 Gestionnaires non asynchrones......................................................................................... 331 Gestionnaires asynchrones............................................................................................... 331 Utilisation de types pour l’objet d’événement....................................................................... 332 Déployez des archives de fichiers .zip........................................................................................ 333 ix AWS Lambda Guide du développeur Utilisation du AWS SAM................................................................................................... 333 Utilisation de la AWS CDK............................................................................................... 334 Utilisation de la AWS CLI et d’esbuild................................................................................ 336 Déployez les images du conteneur............................................................................................ 338 Utilisation d’une image de base......................................................................................... 338 Erreurs.................................................................................................................................. 341 Travail avec Python......................................................................................................................... 343 Gestionnaire........................................................................................................................... 345 Dénomination................................................................................................................. 345 Fonctionnement.............................................................................................................. 345 Renvoi d'une valeur......................................................................................................... 346 Exemples....................................................................................................................... 346 Déploiement d’archives de fichiers .zip....................................................................................... 349 Prérequis....................................................................................................................... 350 Qu’est-ce qu’une dépendance d’environnement d’exécution ?................................................ 350 Package de déploiement sans dépendance......................................................................... 350 Package de déploiement avec dépendances....................................................................... 351 Utilisation d’un environnement virtuel.................................................................................. 352 Déployez votre fichier .zip sur la fonction............................................................................ 352 Déploiement d’images de conteneur.......................................................................................... 354 AWS images de base pour Python.................................................................................... 354 Création d’une image Python à partir d’une image de base AWS............................................ 355 Créer une image Python à partir d’une autre image de base.................................................. 356 Clients d’interface d’exécution Python................................................................................ 356 Déployer l'image de conteneur.......................................................................................... 356 Contexte................................................................................................................................ 357 Journalisation......................................................................................................................... 359 Création d'une fonction qui renvoie des journaux................................................................. 359 Utilisation de la console Lambda....................................................................................... 360 Utilisation de la console CloudWatch.................................................................................. 360 Utilisation de AWS Command Line Interface (AWS CLI)........................................................ 360 Suppression de journaux.................................................................................................. 363 Bibliothèque de journalisation............................................................................................ 363 Erreurs.................................................................................................................................. 364 Fonctionnement.............................................................................................................. 364 Utilisation de la console Lambda....................................................................................... 365 Utilisation de AWS Command Line Interface (AWS CLI)........................................................ 365 Gestion des erreurs dans d’autres services AWS................................................................. 366 Exemples d'erreurs.......................................................................................................... 366 Exemples d'applications................................................................................................... 367 Quelle est la prochaine étape ? ......................................................................................... 322 Tracing.................................................................................................................................. 368 Utilisation d’ADOT pour instrumenter vos fonctions python..................................................... 368 Utilisation du kit SDK X-Ray pour instrumenter vos fonctions Python....................................... 369 Activation du suivi avec la console Lambda......................................................................... 369 Activation du suivi avec l’API Lambda................................................................................ 370 Activation du suivi avec AWS CloudFormation..................................................................... 370 Interprétation d'un suivi X-Ray........................................................................................... 370 Stockage des dépendances d’exécution dans une couche (kit SDK X-Ray)............................... 372 Utilisation de Ruby.......................................................................................................................... 374 Gestionnaire........................................................................................................................... 377 Déploiement d'archives de fichiers .zip....................................................................................... 378 Prerequisites.................................................................................................................. 378 Outils et bibliothèques...................................................................................................... 379 Mise à jour d'une fonction sans dépendances...................................................................... 379 Mise à jour d'une fonction avec dépendances supplémentaires............................................... 379 Déploiement d’images de conteneur.......................................................................................... 381 x

Description:

owned by Amazon are the property of their respective owners, who may or . Configuration d'une fonction Lambda pour l'accès à un Amazon VPC .