Membangun tanpa server kami sendiri berdasarkan Fn

Komputasi tanpa server adalah salah satu tren paling menonjol dalam komputasi awan. Prinsip operasi dasarnya adalah bahwa infrastruktur bukanlah urusan DevOps, tetapi penyedia layanan. Penskalaan sumber daya secara otomatis menyesuaikan dengan beban dan memiliki tingkat perubahan yang tinggi.

Fitur umum lainnya adalah kecenderungan untuk meminimalkan dan memfokuskan kode, itulah sebabnya komputasi tanpa server terkadang disebut function as a service (FaaS).

Secara historis, penyedia cloud pertama yang menawarkan FaaS dengan AWS Lambda adalah Amazon, sesuai dengan namanya. Penyedia layanan cloud lainnya juga menawarkan hal serupa:

• Fungsi Cloud dari Google
• Fungsi Azure dari Microsoft

Semua perusahaan ini menyediakan komputasi tanpa server, penskalaan otomatis, dan hanya membayar sesuai apa yang benar-benar Anda gunakan, namun mereka mengunci pelanggan pada produk milik mereka. Namun, ada alternatif sumber terbuka dan gratis untuk komputasi tanpa server. Perlu diperhatikan:

• Platform Apache OpenWhisk, dikembangkan dalam inkubator oleh IBM,
• Fungsi Cloud Musim Semi, sebagai bagian dari ekosistem Spring Framework yang cukup kaya, yang juga dapat digunakan sebagai fasad untuk AWS Lambda, Azure Functions, dan OpenWhisk,
• Proyek Fn, didukung oleh Oracle.

Semuanya sepenuhnya independen dari cloud, artinya dapat dipasang di cloud mana pun, termasuk milik Anda, publik atau pribadi, dan tentu saja di Exoscale.

Cara kerja proyek Fn

Fn sepenuhnya berbasis Docker, terdiri dari dua komponen utama:

• Program CLI dirancang untuk mengelola semua aspek infrastruktur Fn, dan berinteraksi dengan server Fn,
• Server Fn sendiri merupakan aplikasi biasa yang dikemas dalam container Docker.

Fungsi yang diterapkan di Fn juga dijalankan dalam wadah terpisah, yang memungkinkan Anda mendukung banyak bahasa pemrograman, misalnya... Clojure!

Argumen fungsi diteruskan ke input standar (STDIN), hasilnya ditulis ke output standar (STDOUT). Jika argumen atau nilai kembalian bukan nilai sederhana (seperti objek JSON), maka dapat dikonversi menggunakan lapisan abstraksi yang disediakan oleh Fn sendiri dalam bentuk Function Development Kit (FDK).

Untuk kenyamanan, kumpulan templat bawaan ditawarkan untuk memfasilitasi penerapan FaaS dalam daftar ekstensif berbagai bahasa dan versinya (Go, berbagai versi Java, Python, dll.).

Membuat FaaS mudah dengan mengikuti diagram ini:

• Menyebarkan fungsi menggunakan Fn CLI: file konfigurasi aplikasi untuk Fn dibuat berdasarkan templat yang dipilih.
• Kami meluncurkan fungsi kami sendiri, sekali lagi menggunakan CLI Fn: gambar kontainer ditempatkan di repositori tertentu, setelah itu server diberitahu tentang keberadaan dan penempatan gambar ini.

Prinsip penyampaian fungsi ke Fn

Instalasi lokal dan pengujian fungsi tanpa server

Mari mulai menginstal Fn di mesin lokal. Pertama, Docker diinstal, seperti yang disyaratkan oleh Fn. Dengan asumsi kita menggunakan Debian/Ubuntu:

$ sudo apt-get update
$ sudo apt-get install docker.io

Atau gunakan manajer paket/Docker yang dibuat sesuai dengan sistem Anda. Kemudian Anda bisa langsung menginstal Fn CLI. Misalnya, menggunakan ikal:

$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | sh

Jika Anda menggunakan OSX dengan Homebrew terinstal, Anda dapat menggunakan cara lain:

$ brew install fn

==> Downloading https://homebrew.bintray.com/bottles/fn-0.5.8.high_sierra.bottle.tar.gz
==> Downloading from https://akamai.bintray.com/b1/b1767fb00e2e69fd9da73427d0926b1d1d0003622f7ddc0dd3a899b2894781ff?__gda__=exp=1538038849~hmac=c702c9335e7785fcbacad1f29afa61244d02f2eebb
######################################################################## 100.0%
==> Pouring fn-0.5.8.high_sierra.bottle.tar.gz
  /usr/local/Cellar/fn/0.5.8: 5 files, 16.7MB

Kami sekarang siap untuk menerapkan fungsi kami menggunakan CLI. Untuk mempermudah, kami akan menggunakan lingkungan peluncuran bawaan, seperti Node:

$ fn init --runtime node --trigger http hellonode

Creating function at: /hellonode
Function boilerplate generated.
func.yaml created.

Direktori baru akan dibuat hellonode untuk mengembangkan lebih lanjut fungsi Fn kami dengan beberapa file konfigurasi dasar. Di dalam direktori yang baru dibuat, Anda dapat membuat aplikasi mengikuti standar bahasa atau runtime pilihan Anda:

# Каталог с node выглядит так:

   hellonode
   ├── func.js
   ├── func.yaml
   └── package.json

# Свежеустановленное окружение Java11 такое:

   hellojava11
   ├── func.yaml
   ├── pom.xml
   └── src
       ├── main
       │   └── java
       │       └── com
       │           └── example
       │               └── fn
       │                   └── HelloFunction.java
       └── test
           └── java
               └── com
                   └── example
                       └── fn
                           └── HelloFunctionTest.java

Fn membuat struktur proyek awal, membuat file func.yaml, berisi pengaturan yang diperlukan untuk Fn, dan menyetel templat untuk kode dalam bahasa yang Anda pilih.

Dalam kasus runtime Node, ini berarti:

$ cat hellonode/func.js

const fdk=require('@fnproject/fdk');

fdk.handle(function(input){
  let name = 'World';
  if (input.name) {
    name = input.name;
  }
  return {'message': 'Hello ' + name}
})

Sekarang kita akan segera menguji fungsi kita secara lokal untuk melihat bagaimana semuanya bekerja.

Pertama, kita akan memulai server Fn. Seperti yang telah disebutkan, server Fn adalah wadah Docker, oleh karena itu, setelah startup, ia akan masuk dan mengambil gambar dari registri Docker.

$ fn start -d                    # запускаем локальный сервер в фоне

Unable to find image 'fnproject/fnserver:latest' locally
latest: Pulling from fnproject/fnserver
ff3a5c916c92: Pull complete
1a649ea86bca: Pull complete
ce35f4d5f86a: Pull complete

...

Status: Downloaded newer image for fnproject/fnserver:latest
668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5

Untuk menjalankan fungsi kami, fungsi tersebut harus “diluncurkan”. Ini membutuhkan имя приложения: Di Fn, semua aplikasi harus ditentukan sebagai namespace untuk fungsi terkait.

Fn CLI akan mencari file tersebut func.yaml di direktori saat ini yang akan digunakan untuk mengkonfigurasi fungsi. Jadi pertama-tama Anda perlu pergi ke direktori kami hellonode.

$ cd hellonode
$ fn deploy --app fnexo --local  # выкатываем функцию локально, имя приложения - fnexo.
                                 # параметр local не заливает образ в удаленный реестр,
                                 # запуская его напрямую

Deploying hellonode to app: fnexo
Bumped to version 0.0.2
Building image nfrankel/hellonode:0.0.3 .
Updating function hellonode using image nfrankel/hellonode:0.0.3...
Successfully created app:  fnexo
Successfully created function: hellonode with nfrankel/hellonode:0.0.3
Successfully created trigger: hellonode-trigger

Seperti yang Anda lihat dari output perintah, image container Docker baru dibuat yang berisi fungsi kami. Fungsinya siap dipanggil, dan kita memiliki dua cara untuk melakukannya:

• menggunakan perintah Fn invoke
• menelpon langsung melalui http

Tantangan invoke melalui Fn itu hanya mengemulasi pekerjaan melalui HTTP untuk pengujian, yang nyaman untuk pengujian cepat:

$ fn invoke fnexo hellonode      # вызываем функцию hellonode приложения fnexo

{"message":"Hello World"}

Untuk memanggil suatu fungsi secara langsung, Anda perlu mengetahui URL lengkapnya:

$ curl http://localhost:8080/t/fnexo/hellonode-trigger

{"message":"Hello World"}

Server Fn menampilkan fungsinya pada port 8080 dan URL fungsi tampak cocok dengan polanya t/app/function, tapi tidak seluruhnya. Melalui HTTP, suatu fungsi tidak dipanggil secara langsung, tetapi melalui apa yang disebut trigger, yang sesuai dengan namanya, “memulai” pemanggilan fungsi. Pemicu didefinisikan dalam `func.yml proyek:

schema_version: 20180708
name: hellonode
version: 0.0.3
runtime: node
entrypoint: node func.js
format: json
triggers:
- name: hellonode-trigger
  type: http
  source: /hellonode-trigger    # URL триггера

Kita dapat mengubah nama pemicu agar sesuai dengan nama fungsi, ini akan menyederhanakan segalanya:

triggers:
- name: hellonode-trigger
  type: http
  source: /hellonode    # совпадает с именем функции

Lalu kita jalankan fungsi pengiriman lagi dan memanggilnya dari pemicu baru:

$ fn deploy --app fnexo hellonode --local
$ curl http://localhost:8080/t/fnexo/hellonode

{"message":"Hello World"}

Semuanya berfungsi! Saatnya beralih ke eksperimen skala penuh dan mempublikasikan FaaS kami di server!

Menginstal layanan fungsi tanpa server pada infrastruktur Anda sendiri

Mari segera instal mesin virtual menggunakan Exoscale CLI. Jika Anda belum mengaturnya, Anda dapat menggunakannya panduan memulai cepat kami. Ini adalah alat keren yang akan lebih meningkatkan produktivitas Anda. Jangan lupa bahwa Anda perlu mengkonfigurasi aturan untuk membuka port 8080 di Grup Keamanan! Perintah berikut akan meluncurkan mesin virtual bersih, siap untuk menghosting fungsi kami:

$ exo firewall create fn-securitygroup
$ exo firewall add fn-securitygroup ssh --my-ip
$ exo firewall add fn-securitygroup -p tcp -P 8080-8080 -c 0.0.0.0/0
$ exo vm create fn-server -s fn-securitygroup

Kemudian Anda dapat melakukan ssh ke mesin virtual dan menginstal server Fn jarak jauh:

$ exo ssh fn-server

The authenticity of host '185.19.30.175 (185.19.30.175)' can't be established.
ECDSA key fingerprint is SHA256:uaCKRYeX4cvim+Gr8StdPvIQ7eQgPuOKdnj5WI3gI9Q.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '185.19.30.175' (ECDSA) to the list of known hosts.
Welcome to Ubuntu 18.04 LTS (GNU/Linux 4.15.0-20-generic x86_64)

Kemudian instal Docker dan server Fn dengan cara yang sama seperti yang telah dilakukan pada mesin lokal, mulai server:

$ sudo apt-get update
$ sudo apt-get install docker.io
$ sudo systemctl start docker
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | sh
$ sudo fn start

...

    ______
   / ____/___
  / /_  / __ 
 / __/ / / / /
/_/   /_/ /_/
    v0.3.643

Fn siap menerima fungsi! Untuk transfer fungsi yang ditargetkan ke server jarak jauh, kami akan menggunakan perintah deploy dari komputer lokal dengan menghilangkan bendera --local.

Selain itu, Fn mengharuskan Anda menentukan lokasi server Fn dan registri Docker. Opsi ini dapat diatur melalui variabel lingkungan FN_API_URL и FN_REGISTRY masing-masing, tetapi juga menawarkan cara yang lebih nyaman untuk mengelola pembuatan dan pengelolaan konfigurasi untuk penerapan dengan mudah.

Dalam istilah Fn, konfigurasi untuk penerapan disebut context. Perintah berikut akan membuat konteksnya:

$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankel

Anda dapat melihat konteks yang tersedia seperti ini:

$ fn list contexts

CURRENT NAME      PROVIDER      API URL                      REGISTRY
    default       default       http://localhost:8080/
    exoscale      default       http://185.19.30.175:8080    nfrankel

Dan beralih ke konteks yang baru saja dibuat seperti ini:

 $ fn use context exoscale

 Now using context: exoscale

Mulai sekarang, pengiriman fitur Fn akan mengunduh image Docker menggunakan akun DockerHub yang dipilih (dalam kasus saya - nfrankel), lalu beri tahu server jauh (dalam contoh ini - http://185.19.30.175:8080) tentang lokasi dan versi gambar terbaru yang berisi fungsi Anda.

$ fn deploy --app fnexo .   # выполняется на локальной машине из каталога hellonode

Deploying function at: /.
Deploying hellonode to app: fnexo
Bumped to version 0.0.5
Building image nfrankel/hellonode:0.0.5 .

Akhirnya:

$ curl http://185.19.30.175:8080/t/fnexo/hellonode

{"message":"Hello World"}

Siklus Hidup Fungsi dalam Komputasi Tanpa Server Berbasis Fn

Keuntungan komputasi tanpa server sesuai kapasitas Anda sendiri

Komputasi tanpa server adalah solusi mudah untuk mengimplementasikan bagian independen aplikasi yang berinteraksi dengan aplikasi atau layanan mikro yang lebih kompleks dengan cepat.

Hal ini sering kali disebabkan oleh biaya tersembunyi untuk mengunci vendor yang dipilih, yang bergantung pada kasus penggunaan dan volume tertentu, dapat menyebabkan biaya lebih tinggi dan berkurangnya fleksibilitas di masa mendatang.

Arsitektur multi-cloud dan hybrid cloud juga menderita dalam kasus ini, karena Anda dapat dengan mudah menemukan diri Anda dalam situasi di mana Anda ingin menggunakan komputasi tanpa server, namun karena kebijakan perusahaan hal ini mungkin tidak dapat dilakukan.

Fn cukup mudah digunakan dan dapat menyediakan antarmuka FaaS yang hampir sama, dengan sedikit overhead. Ini menghilangkan vendor lock-in dan dapat diinstal secara lokal atau di penyedia solusi cloud pilihan Anda. Ada juga kebebasan dalam memilih bahasa pemrograman.

Artikel ini hanya membahas dasar-dasar Fn, namun membuat runtime Anda sendiri cukup sederhana, dan keseluruhan arsitektur dapat diterapkan secara lebih luas menggunakan penyeimbang beban Fn, atau dengan menempatkan Fn di belakang proxy untuk perlindungan.

Sumber: www.habr.com