ProHoster > Blog > Pentadbiran > Membina tanpa pelayan kami sendiri berdasarkan Fn

Membina tanpa pelayan kami sendiri berdasarkan Fn

Membina tanpa pelayan kami sendiri berdasarkan Fn

Pengkomputeran tanpa pelayan adalah salah satu trend yang paling menonjol dalam pengkomputeran awan. Prinsip operasi asas ialah infrastruktur bukan kebimbangan DevOps, tetapi pembekal perkhidmatan. Penskalaan sumber secara automatik melaraskan kepada pemuatan dan mempunyai kadar perubahan yang tinggi.

Satu lagi ciri biasa ialah kecenderungan untuk meminimumkan dan memfokuskan kod, itulah sebabnya pengkomputeran tanpa pelayan kadangkala dipanggil fungsi sebagai perkhidmatan (FaaS).

Dari segi sejarah, penyedia awan pertama yang menawarkan FaaS dengan AWS Lambda ialah Amazon, oleh itu namanya. Pembekal perkhidmatan awan lain juga menawarkan yang serupa:

  • Fungsi Awan daripada Google
  • Azure Functions daripada Microsoft

Semua syarikat ini menyediakan pengkomputeran tanpa pelayan, penskalaan automatik dan hanya membayar untuk apa yang sebenarnya anda gunakan, tetapi mereka mengunci pelanggan ke dalam produk proprietari mereka. Walau bagaimanapun, terdapat alternatif percuma dan sumber terbuka untuk pengkomputeran tanpa pelayan. Perlu diperhatikan:

  • Pelantar Apache OpenWhisk, dibangunkan dalam inkubator oleh IBM,
  • Fungsi Awan Musim Bunga, sebagai sebahagian daripada ekosistem Spring Framework yang cukup kaya, yang juga boleh digunakan sebagai fasad untuk AWS Lambda, Azure Functions dan OpenWhisk,
  • Projek Fn, disokong oleh Oracle.

Kesemuanya adalah bebas sepenuhnya daripada awan, iaitu, ia boleh dipasang dalam mana-mana awan, termasuk awan anda sendiri, awam atau peribadi, dan sudah tentu dalam Exoscale.

Cara projek Fn berfungsi

Fn sepenuhnya berdasarkan Docker, terdiri daripada dua komponen utama:

  • Program CLI direka untuk mengurus semua aspek infrastruktur Fn, dan berinteraksi dengan pelayan Fn,
  • Pelayan Fn itu sendiri ialah aplikasi biasa yang dibungkus dalam bekas Docker.

Fungsi yang digunakan dalam Fn juga dilaksanakan dalam bekas berasingan, yang membolehkan anda menyokong banyak bahasa pengaturcaraan, contohnya... Clojure!

Argumen fungsi dihantar kepada input standard (STDIN), keputusan ditulis kepada output standard (STDOUT). Jika argumen atau nilai pulangan bukan nilai mudah (seperti objek JSON), ia boleh ditukar menggunakan lapisan abstraksi yang disediakan oleh Fn sendiri dalam bentuk Kit Pembangunan Fungsi (FDK).

Untuk kemudahan, set templat terbina dalam ditawarkan untuk memudahkan penggunaan FaaS dalam senarai luas bahasa yang berbeza dan versinya (Go, versi Java, Python, dll. yang berbeza).

Mencipta FaaS adalah mudah dengan mengikuti rajah ini:

  • Menggunakan fungsi menggunakan Fn CLI: fail konfigurasi aplikasi untuk Fn dibuat berdasarkan templat yang dipilih.
  • Kami melancarkan fungsi kami sendiri, sekali lagi menggunakan CLI Fn: imej kontena diletakkan dalam repositori tertentu, selepas itu pelayan dimaklumkan tentang kewujudan dan penempatan imej ini.

Membina tanpa pelayan kami sendiri berdasarkan Fn
Prinsip penyampaian fungsi kepada Fn

Pemasangan tempatan dan ujian fungsi tanpa pelayan

Mari mulakan memasang Fn pada mesin tempatan. Pertama, Docker dipasang seperti yang diperlukan oleh Fn. Dengan mengandaikan kita berada di Debian/Ubuntu:

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

Atau gunakan pengurus pakej/binaan Docker mengikut sistem anda. Kemudian anda boleh terus memasang Fn CLI. Contohnya, menggunakan curl:

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

Jika anda menggunakan OSX dengan Homebrew dipasang, anda boleh 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 kini bersedia untuk menggunakan fungsi kami pada mulanya menggunakan CLI. Untuk kesederhanaan, kami akan menggunakan persekitaran pelancaran terbina dalam, seperti Node:

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

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

Direktori baharu akan dibuat hellonode untuk mengembangkan lagi fungsi Fn kami dengan beberapa fail konfigurasi asas. Di dalam direktori yang baru dibuat, anda boleh membuat aplikasi anda mengikut piawaian bahasa atau masa jalan yang anda pilih:

# Каталог с 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 mencipta struktur projek awal, mencipta fail func.yaml, mengandungi tetapan yang diperlukan untuk Fn, dan menetapkan templat untuk kod dalam bahasa yang anda pilih.

Dalam kes masa jalan Node, ini bermakna:

$ 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 kami akan menguji fungsi kami secara tempatan dengan cepat untuk melihat cara semuanya berfungsi.

Pertama, kami akan memulakan pelayan Fn. Seperti yang telah disebutkan, pelayan Fn adalah bekas Docker, oleh itu, selepas permulaan, ia akan pergi dan mengambil imej dari pendaftaran 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, ia mesti "dilancarkan". Ini memerlukan имя приложения: Dalam Fn, semua aplikasi mesti dinyatakan sebagai ruang nama untuk fungsi yang berkaitan.

Fn CLI akan mencari fail tersebut func.yaml dalam direktori semasa yang akan digunakan untuk mengkonfigurasi fungsi. Jadi pertama 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 daripada output arahan, imej bekas Docker baharu dicipta yang mengandungi fungsi kami. Fungsi sedia untuk dipanggil, dan kami mempunyai dua cara untuk melakukannya:

  • menggunakan arahan Fn invoke
  • menghubungi terus melalui http

Panggil invoke melalui Fn ia hanya meniru kerja melalui HTTP untuk ujian, yang sesuai untuk ujian pantas:

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

{"message":"Hello World"}

Untuk memanggil fungsi secara langsung, anda perlu mengetahui URL penuh:

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

{"message":"Hello World"}

Pelayan Fn mendedahkan fungsinya pada port 8080 dan URL fungsi kelihatan sepadan dengan corak t/app/function, tetapi tidak sepenuhnya. Melalui HTTP, fungsi tidak dipanggil secara langsung, tetapi melalui pencetus yang dipanggil, yang, mengikut namanya, "memulakan" panggilan fungsi. Pencetus ditakrifkan dalam `func.yml projek:

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 boleh menukar nama pencetus agar sepadan dengan nama fungsi, ini akan memudahkan segala-galanya:

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

Kemudian kami mula menyampaikan fungsi itu sekali lagi dan memanggilnya daripada pencetus baharu:

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

{"message":"Hello World"}

Semuanya berfungsi! Sudah tiba masanya untuk beralih kepada percubaan berskala penuh dan menerbitkan FaaS kami pada pelayan!

Memasang perkhidmatan fungsi tanpa pelayan pada infrastruktur anda sendiri

Mari pasang mesin maya dengan cepat menggunakan Exoscale CLI. Jika anda belum menyediakannya lagi, anda boleh menggunakannya panduan permulaan pantas kami. Ini adalah alat hebat yang akan meningkatkan produktiviti anda dengan lebih banyak lagi. Jangan lupa bahawa anda perlu mengkonfigurasi peraturan untuk membuka port 8080 dalam Kumpulan Keselamatan! Perintah berikut akan melancarkan mesin maya yang bersih, sedia untuk mengehoskan 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 boleh ssh ke dalam mesin maya dan memasang pelayan Fn 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 pasang Docker dan pelayan Fn dengan cara yang sama seperti yang telah dilakukan pada mesin tempatan, mulakan pelayan:

$ 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 sedia menerima fungsi! Untuk pemindahan fungsi yang disasarkan ke pelayan jauh, kami akan menggunakan arahan deploy daripada komputer tempatan dengan meninggalkan bendera --local.

Selain itu, Fn memerlukan anda untuk menentukan lokasi pelayan Fn dan pendaftaran Docker. Pilihan ini boleh ditetapkan melalui pembolehubah persekitaran FN_API_URL и FN_REGISTRY masing-masing, tetapi juga menawarkan cara yang lebih mudah untuk mengurus penciptaan dan pengurusan konfigurasi untuk penempatan dengan mudah.

Dalam istilah Fn, konfigurasi untuk penempatan dipanggil context. Perintah berikut akan mencipta konteks:

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

Anda boleh 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 kepada konteks yang baru dibuat seperti ini:

 $ fn use context exoscale

 Now using context: exoscale

Dari sini, penghantaran ciri Fn akan memuat turun imej Docker menggunakan akaun DockerHub yang dipilih (dalam kes saya - nfrankel), dan kemudian memberitahu pelayan jauh (dalam contoh ini - http://185.19.30.175:8080) tentang lokasi dan versi imej terkini yang mengandungi 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"}

Membina tanpa pelayan kami sendiri berdasarkan Fn
Kitaran Hayat Fungsi dalam Pengkomputeran Tanpa Pelayan Berasaskan Fn

Kelebihan pengkomputeran tanpa pelayan pada kapasiti anda sendiri

Pengkomputeran tanpa pelayan ialah penyelesaian mudah untuk melaksanakan bahagian bebas aplikasi dengan pantas yang berinteraksi dengan aplikasi atau perkhidmatan mikro yang lebih kompleks.

Ini selalunya disebabkan oleh kos tersembunyi untuk mengunci vendor yang dipilih, yang, bergantung pada kes penggunaan dan volum penggunaan tertentu, boleh menyebabkan kos yang lebih tinggi dan mengurangkan fleksibiliti pada masa hadapan.

Seni bina awan berbilang awan dan hibrid juga mengalami masalah dalam kes ini, kerana anda boleh dengan mudah mendapati diri anda berada dalam situasi di mana anda ingin menggunakan pengkomputeran tanpa pelayan, tetapi disebabkan oleh dasar korporat ia mungkin tidak dapat dilakukan.

Fn agak mudah untuk digunakan dan boleh menyediakan antara muka FaaS yang hampir sama, dengan sedikit overhed. Ia menghapuskan sebarang kunci masuk vendor dan boleh dipasang secara tempatan atau dalam mana-mana penyedia penyelesaian awan yang mudah pilihan anda. Terdapat juga kebebasan dalam memilih bahasa pengaturcaraan.

Artikel ini hanya merangkumi asas Fn, tetapi membuat masa jalan anda sendiri agak mudah, dan seni bina keseluruhan boleh digunakan dengan lebih meluas menggunakan pengimbang beban Fn, atau dengan meletakkan Fn di belakang proksi untuk perlindungan.

Sumber: www.habr.com

Tambah komen