Informatique sans serveur avec AWS Lambda, partie 1

L'informatique sans serveur est peut-être la chose la plus en vogue dans le cloud computing aujourd'hui, mais qu'est-ce que c'est exactement? Ce didacticiel en deux parties commence par un aperçu de l'informatique sans serveur - de ce qu'il est, pourquoi il est considéré comme perturbateur par rapport au cloud computing traditionnel et comment vous pouvez l'utiliser dans la programmation Java.

Après la présentation, vous obtiendrez une introduction pratique à AWS Lambda, qui est considérée par beaucoup comme la première solution basée sur Java pour l'informatique sans serveur aujourd'hui. Dans la partie 1, vous utiliserez AWS Lambda pour créer, déployer et tester votre première fonction Lambda en Java. Dans la partie 2, vous allez intégrer votre fonction Lambda à DynamoDB, puis utiliser le kit AWS SDK pour appeler des fonctions Lambda dans une application Java.

Qu'est-ce que l'informatique sans serveur?

L'année dernière, je parlais à un stagiaire de l'entreprise de différents modèles architecturaux et de l'architecture sans serveur. Il n'a pas tardé à remarquer que toutes les applications nécessitent un serveur et ne peuvent pas fonctionner à vide. Le stagiaire avait raison, même s'il manquait le mien. L'informatique sans serveur n'est pas une plate-forme magique pour exécuter des applications.

En fait, l' informatique sans serveur signifie simplement que vous, le développeur, n'avez pas à vous occuper du serveur. Une plate-forme informatique sans serveur comme AWS Lambda vous permet de créer votre code et de le déployer sans jamais avoir besoin de configurer ou de gérer les serveurs sous-jacents. Votre unité de déploiement est votre code; pas le conteneur qui héberge le code, ou le serveur qui exécute le code, mais simplement le code lui-même. Du point de vue de la productivité, il y a des avantages évidents à décharger les détails de l'emplacement de stockage du code et de la façon dont l'environnement d'exécution est géré. L'informatique sans serveur est également tarifée en fonction des métriques d'exécution, il y a donc également un avantage financier.

Combien coûte AWS Lambda?

Au moment de la rédaction de cet article, le niveau de prix d'AWS Lambda est basé sur le nombre d'exécutions et la durée d'exécution:

  • Vos premiers millions d'exécutions par mois sont gratuits, puis vous payez 0,20 USD par million d'exécutions par la suite (0,0000002 USD par demande).
  • La durée est calculée à partir du moment où votre code commence à s'exécuter jusqu'à ce qu'il renvoie un résultat, arrondi aux 100 ms les plus proches. Le montant facturé est basé sur la quantité de RAM allouée à la fonction, où le coût est de 0,00001667 USD pour chaque Go-seconde.

Les détails de tarification et les allocations de niveaux gratuits sont légèrement plus compliqués que ne le laisse supposer l'aperçu. Consultez le niveau de prix pour découvrir quelques scénarios de tarification.

Pour avoir une idée du fonctionnement de l'informatique sans serveur, commençons par le modèle d'exécution de l'informatique sans serveur, illustré à la figure 1.

Steven Haines

Voici le modèle d'exécution sans serveur en quelques mots:

  1. Un client demande à la plate-forme informatique sans serveur d'exécuter une fonction spécifique.
  2. La plate-forme informatique sans serveur vérifie d'abord si la fonction s'exécute sur l'un de ses serveurs. Si la fonction n'est pas déjà en cours d'exécution, la plate-forme charge la fonction à partir d'un magasin de données.
  3. La plate-forme déploie ensuite la fonction sur l'un de ses serveurs, qui sont préconfigurés avec un environnement d'exécution pouvant exécuter la fonction.
  4. Il exécute la fonction et capture le résultat.
  5. Il renvoie le résultat au client.

Parfois, l'informatique sans serveur est appelée fonction en tant que service (FaaS), car la granularité du code que vous créez est une fonction . La plateforme exécute votre fonction sur son propre serveur et orchestre le processus entre les demandes de fonction et les réponses de fonction.

Nanoservices, évolutivité et prix

Trois choses comptent vraiment dans l'informatique sans serveur: son architecture de nanoservices; le fait qu'il est pratiquement infiniment évolutif; et le modèle de tarification associé à cette évolutivité quasi infinie. Nous allons approfondir chacun de ces facteurs.

Nanoservices

Vous avez entendu parler des microservices, et vous connaissez probablement les applications à 12 facteurs, mais les fonctions sans serveur amènent le paradigme de décomposer un composant en ses composants à un tout autre niveau. Le terme «nanoservices» n'est pas un terme reconnu par l'industrie, mais l'idée est simple: chaque nanoservice doit mettre en œuvre une action ou une responsabilité unique. Par exemple, si vous vouliez créer un widget, l'acte de création serait son propre nanoservice; si vous vouliez récupérer un widget, l'acte de récupération serait également un nanoservice; et si vous vouliez passer une commande pour un widget, cette commande serait encore un autre nanoservice.

Une architecture nanoservices vous permet de définir votre application à un niveau très fin. Similaire au développement piloté par les tests (qui vous permet d'éviter les effets secondaires indésirables en écrivant votre code au niveau des tests individuels), une architecture de nanoservices encourage la définition de votre application en termes de fonctions très fines et spécifiques. Cette approche augmente la clarté de ce que vous créez et réduit les effets secondaires indésirables du nouveau code.

Microservices vs nanoservices

Microservices nous encourage à décomposer une application en un ensemble de services qui accomplissent chacun une tâche spécifique. Le défi est que personne n'a vraiment quantifié la portée d'un microservice. En conséquence, nous finissons par définir les microservices comme un ensemble de services associés, tous interagissant avec le même modèle de données. Conceptuellement, si vous avez une fonctionnalité de bas niveau interagissant avec un modèle de données donné, la fonctionnalité doit entrer dans l'un de ses services associés. Les interactions de haut niveau doivent faire des appels au service plutôt que d'interroger directement la base de données.

Il y a un débat en cours dans l'informatique sans serveur sur l'opportunité de créer des fonctions Lambda au niveau des microservices ou des nanoservices. La bonne nouvelle est que vous pouvez facilement créer vos fonctions avec l'une ou l'autre granularité, mais une stratégie de microservices nécessitera un peu de logique de routage supplémentaire dans votre gestionnaire de requêtes.

Du point de vue de la conception, les applications sans serveur doivent être très bien définies et propres. Du point de vue du déploiement, vous devrez gérer beaucoup plus de déploiements, mais vous aurez également la possibilité de déployer de nouvelles versions de vos fonctions individuellement, sans affecter les autres fonctions. L'informatique sans serveur est particulièrement bien adaptée au développement dans de grandes équipes, où elle peut aider à rendre le processus de développement plus facile et le code moins sujet aux erreurs.

Évolutivité

En plus d'introduire un nouveau paradigme architectural, les plates-formes informatiques sans serveur offrent une évolutivité pratiquement infinie. Je dis "pratiquement" parce qu'il n'y a pas vraimentévolutivité infinie. À toutes fins pratiques, cependant, les fournisseurs d'informatique sans serveur comme Amazon peuvent gérer plus de charge que vous ne pourriez leur en imposer. Si vous deviez gérer la mise à l'échelle de vos propres serveurs (ou machines virtuelles basées sur le cloud) pour répondre à une demande accrue, vous auriez besoin de surveiller l'utilisation, d'identifier quand démarrer davantage de serveurs et d'ajouter plus de serveurs à votre cluster au bon moment. De même, lorsque la demande diminuait, vous devrez réduire manuellement. Avec l'informatique sans serveur, vous indiquez à votre plate-forme informatique sans serveur le nombre maximum de demandes de fonctions simultanées que vous souhaitez exécuter et la plate-forme effectue la mise à l'échelle pour vous.

Tarification

Finally, the serverless computing pricing model allows you to scale your cloud bill based on usage. When you have light usage, your bill will be low (or nil if you stay in the free range). Of course, your bill will increase with usage, but hopefully you will also have new revenue to support your higher cloud bill. For contrast, if you were to manage your own servers, you would have to pay a base cost to run the minimum number of servers required. As usage increased, you would scale up in increments of entire servers, rather than increments of individual function calls. The serverless computing pricing model is directly proportional to your usage.

AWS Lambda for serverless computing

AWS Lambda est une plate-forme informatique sans serveur implémentée au-dessus des plates-formes Amazon Web Services telles que EC2 et S3. AWS Lambda crypte et stocke votre code dans S3. Lorsqu'une fonction est demandée pour s'exécuter, elle crée un «conteneur» à l'aide de vos spécifications d'exécution, le déploie sur l'une des instances EC2 de sa batterie de calcul et exécute cette fonction. Le processus est illustré à la figure 2.

Steven Haines

When you create a Lambda function, you configure it in AWS Lambda, specifying things like the runtime environment (we'll use Java 8 for this article), how much memory to allocate to it, identity and access management roles, and the method to execute. AWS Lambda uses your configuration to setup a container and deploy the container to an EC2 instance. It then executes the method that you've specified, in the order of package, class, and method.

At the time of this writing, you can build Lambda functions in Node, Java, Python, and most recently, C#. For the purposes of this article we will use Java.

What is a Lambda function?

When you write code designed to run in AWS Lambda, you are writing functions. The term functions comes from functional programming, which originated in lambda calculus. The basic idea is to compose an application as a collection of functions, which are methods that accept arguments, compute a result, and have no unwanted side-effects. Functional programming takes a mathematical approach to writing code that can be proven to be correct. While it's good to keep functional programming in mind when you are writing code for AWS Lambda, all you really need to understand is that the function is a single-method entry-point that accepts an input object and returns an output object.

Serverless execution modes

While Lambda functions can run synchronously, as described above, they can also run asynchronously and in response to events. For example, you could configure a Lambda to run whenever a file was uploaded to an S3 bucket. This configuration is sometimes used for image or video processing: when a new image is uploaded to an S3 bucket, a Lambda function is invoked with a reference to the image to process it.

I worked with a very large company that leveraged this solution for photographers covering a marathon. The photographers were on the course taking photographs. Once their memory cards were full, they loaded the images onto a laptop and uploaded the files to S3. As images were uploaded, Lambda functions were executed to resize, watermark, and add a reference for each image to its runner in the database.

All of this would take a lot of work to accomplish manually, but in this case the work not only processed faster because of AWS Lambda's horizontal scalability, but also seamlessly scaled up and back down, thus optimizing the company's cloud bill.

In addition to responding to files uploaded to S3, lambdas can be triggered by other sources, such as records being inserted into a DynamoDB database and analytic information streaming from Amazon Kinesis. We'll look at an example featuring DynamoDB in Part 2.

AWS Lambda functions in Java

Now that you know a little bit about serverless computing and AWS Lambda, I'lll walk you through building an AWS Lambda function in Java. 

télécharger Obtenez le code Code source de l'exemple d'application de ce didacticiel, «Informatique sans serveur avec AWS Lambda». Créé par Steven Haines pour JavaWorld.

Implémentation des fonctions Lambda

Vous pouvez écrire une fonction Lambda de deux manières:

  • La fonction peut recevoir un flux d'entrée vers le client et écrire dans un flux de sortie vers le client.
  • La fonction peut utiliser une interface prédéfinie, auquel cas AWS Lambda désérialise automatiquement le flux d'entrée vers un objet, le transmet à votre fonction et sérialise la réponse de votre fonction avant de la renvoyer au client.

Le moyen le plus simple d'implémenter une fonction AWS Lambda consiste à utiliser une interface prédéfinie. Pour Java, vous devez d'abord inclure la bibliothèque principale AWS Lambda suivante dans votre projet (notez que cet exemple utilise Maven):

 com.amazonaws aws-lambda-java-core 1.1.0  

Next, have your class implement the following interface:

Listing 1. RequestHandler.java

 public interface RequestHandler { /** * Handles a Lambda function request * @param input The Lambda function input * @param context The Lambda execution environment context object. * @return The Lambda function output */ public O handleRequest(I input, Context context); } 

The RequestHandler interface defines a single method: handleRequest(), which is passed an input object and a Context object, and returns an output object. For example, if you were to define a Request class and a Response class, you could implement your lambda as follows:

 public class MyHandler implements RequestHandler { public Response handleRequest(Request request, Context context) { ... } } 

Alternatively, if you wanted to bypass the predefined interface, you could manually handle the InputStream and OutputStream yourself, by implementing a method with the following signature:

 public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) throws IOException { ... } 

The Context object provides information about your function and the environment in which it is running, such as the function name, its memory limit, its logger, and the amount of time remaining, in milliseconds, that the function has to complete before AWS Lambda kills it.