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 .
ebook img

AWS Lambda PDF

477 Pages·2017·5.11 MB·English
by  Amazon Web Services
#amazon #amazon aws #aws
Save to my drive
Quick download
Download

Download AWS Lambda PDF Free - Full Version

by Amazon Web Services| 2017| 477 pages| 5.11| English

Download AWS Lambda by Amazon Web Services in PDF format completely FREE. No registration required, no payment needed. Get instant access to this valuable resource on PDFdrive.to!

Free Download PDF

About AWS Lambda

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 .

Detailed Information

Author:Amazon Web Services
Publication Year:2017
Pages:477
Language:English
File Size:5.11
Format:PDF
Price:FREE
Download Free PDF

Safe & Secure Download - No registration required

Why Choose PDFdrive for Your Free AWS Lambda Download?

  • 100% Free: No hidden fees or subscriptions required for one book every day.
  • No Registration: Immediate access is available without creating accounts for one book every day.
  • Safe and Secure: Clean downloads without malware or viruses
  • Multiple Formats: PDF, MOBI, Mpub,... optimized for all devices
  • Educational Resource: Supporting knowledge sharing and learning

Free Books Similar to AWS Lambda

Frequently Asked Questions

Is it really free to download AWS Lambda PDF?

Yes, on https://PDFdrive.to you can download AWS Lambda by Amazon Web Services completely free. We don't require any payment, subscription, or registration to access this PDF file. For 3 books every day.

How can I read AWS Lambda on my mobile device?

After downloading AWS Lambda PDF, you can open it with any PDF reader app on your phone or tablet. We recommend using Adobe Acrobat Reader, Apple Books, or Google Play Books for the best reading experience.

Is this the full version of AWS Lambda?

Yes, this is the complete PDF version of AWS Lambda by Amazon Web Services. You will be able to read the entire content as in the printed version without missing any pages.

Is it legal to download AWS Lambda PDF for free?

https://PDFdrive.to provides links to free educational resources available online. We do not store any files on our servers. Please be aware of copyright laws in your country before downloading.

The materials shared are intended for research, educational, and personal use in accordance with fair use principles.

We use cookies

We use cookies to ensure you get the best browsing experience on our website. By clicking "Accept Cookies", you agree that we can store cookies on your device in accordance with our Terms and Privacy.