Komputasi tanpa server dengan AWS Lambda, Bagian 1

Komputasi tanpa server mungkin menjadi hal terpanas dalam komputasi awan saat ini, tetapi apa sebenarnya itu? Tutorial dua bagian ini dimulai dengan ikhtisar komputasi tanpa server - dari apa itu, mengapa dianggap mengganggu komputasi awan tradisional, dan bagaimana Anda dapat menggunakannya dalam pemrograman berbasis Java.

Setelah ikhtisar, Anda akan mendapatkan pengenalan langsung ke AWS Lambda, yang dianggap oleh banyak solusi perdana berbasis Java untuk komputasi tanpa server saat ini. Di Bagian 1, Anda akan menggunakan AWS Lambda untuk membangun, menerapkan, dan menguji fungsi Lambda pertama Anda di Java. Di Bagian 2, Anda akan mengintegrasikan fungsi Lambda Anda dengan DynamoDB, lalu menggunakan AWS SDK untuk menjalankan fungsi Lambda di aplikasi Java.

Apa itu komputasi tanpa server?

Tahun lalu saya berbicara dengan seorang karyawan magang tentang pola arsitektur yang berbeda dan menyebutkan arsitektur tanpa server. Dia cepat mencatat bahwa semua aplikasi membutuhkan server, dan tidak dapat berjalan di udara. Magang ada benarnya, bahkan jika dia merindukan milikku. Komputasi tanpa server bukanlah platform ajaib untuk menjalankan aplikasi.

Faktanya, komputasi tanpa server berarti bahwa Anda, pengembang, tidak perlu berurusan dengan server. Platform komputasi tanpa server seperti AWS Lambda memungkinkan Anda membuat kode dan menerapkannya tanpa perlu mengonfigurasi atau mengelola server yang mendasarinya. Unit penerapan Anda adalah kode Anda; bukan penampung yang menghosting kode, atau server yang menjalankan kode, tetapi hanya kode itu sendiri. Dari sudut pandang produktivitas, ada manfaat yang jelas dari pembongkaran detail di mana kode disimpan dan bagaimana lingkungan eksekusi dikelola. Komputasi tanpa server juga ditentukan harga berdasarkan metrik eksekusi, jadi ada keuntungan finansial juga.

Berapa biaya AWS Lambda?

Pada saat penulisan ini, tingkat harga AWS Lambda didasarkan pada jumlah eksekusi dan durasi eksekusi:

  • Satu juta eksekusi pertama Anda per bulan gratis, kemudian Anda membayar $ 0,20 per juta eksekusi setelahnya ($ 0,0000002 per permintaan).
  • Durasi dihitung dari saat kode Anda mulai dijalankan hingga mengembalikan hasil, dibulatkan ke 100 md terdekat. Jumlah yang dibebankan didasarkan pada jumlah RAM yang dialokasikan untuk fungsi tersebut, dengan biaya $ 0,00001667 untuk setiap GB-detik.

Detail harga dan alokasi tingkat gratis sedikit lebih rumit daripada yang tersirat dalam ikhtisar. Kunjungi tingkat harga untuk melihat beberapa skenario penetapan harga.

Untuk mendapatkan gambaran tentang cara kerja komputasi tanpa server, mari kita mulai dengan model eksekusi komputasi tanpa server, yang diilustrasikan pada Gambar 1.

Steven Haines

Berikut model eksekusi tanpa server secara singkat:

  1. Seorang klien membuat permintaan ke platform komputasi tanpa server untuk menjalankan fungsi tertentu.
  2. Platform komputasi tanpa server terlebih dahulu memeriksa apakah fungsi tersebut berjalan di salah satu servernya. Jika fungsinya belum berjalan, platform memuat fungsi dari penyimpanan data.
  3. Platform kemudian menerapkan fungsi tersebut ke salah satu servernya, yang telah dikonfigurasikan sebelumnya dengan lingkungan eksekusi yang dapat menjalankan fungsi tersebut.
  4. Ini menjalankan fungsi dan menangkap hasilnya.
  5. Ini mengembalikan hasilnya kembali ke klien.

Terkadang komputasi tanpa server disebut Function as a Service (FaaS), karena granularitas kode yang Anda buat adalah sebuah fungsi . Platform menjalankan fungsi Anda di servernya sendiri dan mengatur proses antara permintaan fungsi dan respons fungsi.

Layanan nano, skalabilitas, dan harga

Tiga hal yang sangat penting tentang komputasi tanpa server: arsitektur layanan nano; fakta bahwa itu secara praktis dapat diskalakan tanpa batas; dan model harga yang terkait dengan skalabilitas yang hampir tak terbatas itu. Kami akan menggali masing-masing faktor tersebut.

Layanan nano

Anda pernah mendengar tentang layanan mikro, dan Anda mungkin tahu tentang aplikasi 12 faktor, tetapi fungsi tanpa server membawa paradigma pemecahan komponen ke bagian-bagian penyusunnya ke tingkat yang sama sekali baru. Istilah "layanan nano" bukanlah istilah yang diakui industri, tetapi idenya sederhana: setiap layanan nano harus menerapkan satu tindakan atau tanggung jawab. Misalnya, jika Anda ingin membuat widget, tindakan penciptaan akan menjadi layanan nano-nya sendiri; jika Anda ingin mengambil widget, tindakan pengambilan juga akan menjadi layanan nano; dan jika Anda ingin memesan widget, pesanan itu akan menjadi layanan nano lainnya.

Arsitektur nanoservices memungkinkan Anda untuk menentukan aplikasi Anda pada tingkat yang sangat detail. Mirip dengan pengembangan yang digerakkan oleh pengujian (yang membantu Anda menghindari efek samping yang tidak diinginkan dengan menulis kode Anda pada tingkat pengujian individual), arsitektur layanan nano mendorong untuk menentukan aplikasi Anda dalam istilah fungsi yang sangat terperinci dan spesifik. Pendekatan ini meningkatkan kejelasan tentang apa yang Anda buat dan mengurangi efek samping yang tidak diinginkan dari kode baru.

Microservices vs nanoservices

Layanan mikro mendorong kami untuk memecah aplikasi menjadi kumpulan layanan yang masing-masing menyelesaikan tugas tertentu. Tantangannya adalah bahwa tidak ada yang benar-benar mengukur cakupan layanan mikro. Akibatnya, kami akhirnya mendefinisikan layanan mikro sebagai kumpulan layanan terkait, semuanya berinteraksi dengan model data yang sama. Secara konseptual, jika Anda memiliki fungsionalitas tingkat rendah yang berinteraksi dengan model data tertentu, fungsionalitas tersebut harus masuk ke salah satu layanan terkaitnya. Interaksi tingkat tinggi harus melakukan panggilan ke layanan daripada membuat kueri database secara langsung.

There is an ongoing debate in serverless computing about whether to build Lambda functions at the level of microservices or nanoservices. The good news is that you can pretty easily build your functions at either granularity, but a microservices strategy will require a bit of extra routing logic in your request handler.

From a design perspective, serverless applications should be very well-defined and clean. From a deployment perspective you will need to manage significantly more deployments, but you will also have the ability to deploy new versions of your functions individually, without impacting other functions. Serverless computing is especially well suited to development in large teams, where it can help make the development process easier and the code less error-prone.

Scalability

In addition to introducing a new architectural paradigm, serverless computing platforms provide practically infinite scalability. I say "practically" because there is no such thing as truly infinite scalability. For all practical purposes, however, serverless computing providers like Amazon can handle more load than you could possibly throw at them. If you were to manage scaling up your own servers (or cloud-based virtual machines) to meet increased demand, you would need to monitor usage, identify when to start more servers, and add more servers to your cluster at the right time. Likewise, when demand decreased you would need to manually scale down. With serverless computing, you tell your serverless computing platform the maximum number of simultaneous function requests you want to run and the platform does the scaling for you.

Pricing

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 adalah platform komputasi tanpa server yang diterapkan di atas platform Amazon Web Services seperti EC2 dan S3. AWS Lambda mengenkripsi dan menyimpan kode Anda di S3. Ketika sebuah fungsi diminta untuk dijalankan, itu membuat sebuah "kontainer" menggunakan spesifikasi runtime Anda, menyebarkannya ke salah satu instans EC2 di farm komputasi, dan menjalankan fungsi itu. Prosesnya ditunjukkan pada Gambar 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. 

unduh Dapatkan kode Sumber kode untuk aplikasi contoh untuk tutorial ini, "Komputasi tanpa server dengan AWS Lambda." Dibuat oleh Steven Haines untuk JavaWorld.

Menerapkan fungsi Lambda

Anda dapat menulis fungsi Lambda dengan salah satu dari dua cara berikut:

  • Fungsi ini dapat menerima aliran masukan ke klien dan menulis ke aliran keluaran kembali ke klien.
  • Fungsi tersebut dapat menggunakan antarmuka yang telah ditentukan sebelumnya, dalam hal ini AWS Lambda akan secara otomatis menghentikan aliran input ke suatu objek, meneruskannya ke fungsi Anda, dan membuat serial respons fungsi Anda sebelum mengembalikannya ke klien.

Cara termudah untuk mengimplementasikan fungsi AWS Lambda adalah dengan menggunakan antarmuka yang telah ditentukan sebelumnya. Untuk Java, Anda harus terlebih dahulu menyertakan pustaka inti AWS Lambda berikut dalam proyek Anda (perhatikan bahwa contoh ini menggunakan 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.