ການສ້າງ serverless ຂອງພວກເຮົາເອງໂດຍອີງໃສ່ Fn

ຄອມພິວເຕີທີ່ບໍ່ມີເຊີບເວີ ແມ່ນຫນຶ່ງໃນທ່າອ່ຽງທີ່ໂດດເດັ່ນທີ່ສຸດໃນຄອມພິວເຕີ້ຟັງ. ຫຼັກການພື້ນຖານຂອງການດໍາເນີນງານແມ່ນວ່າໂຄງສ້າງພື້ນຖານບໍ່ແມ່ນຄວາມກັງວົນຂອງ DevOps, ແຕ່ຂອງຜູ້ໃຫ້ບໍລິການ. ການຂະຫຍາຍຊັບພະຍາກອນອັດຕະໂນມັດປັບການໂຫຼດແລະມີອັດຕາການປ່ຽນແປງສູງ.

ລັກສະນະທົ່ວໄປອີກອັນຫນຶ່ງແມ່ນແນວໂນ້ມທີ່ຈະຫຼຸດຫນ້ອຍລົງແລະລະຫັດໂຟກັສ, ນັ້ນແມ່ນເຫດຜົນທີ່ຄອມພິວເຕີ້ເຊີຟເວີບາງຄັ້ງເອີ້ນວ່າຫນ້າທີ່ເປັນບໍລິການ (FaaS).

ໃນປະຫວັດສາດ, ຜູ້ໃຫ້ບໍລິການຟັງທໍາອິດທີ່ສະເຫນີ FaaS ກັບ AWS Lambda ແມ່ນ Amazon, ດັ່ງນັ້ນຊື່. ຜູ້ໃຫ້ບໍລິການ cloud ອື່ນໆຍັງສະເຫນີທີ່ຄ້າຍຄືກັນ:

• ຟັງຊັນຄລາວຈາກ Google
• ຟັງຊັນ Azure ຈາກ Microsoft

ບໍລິສັດທັງຫມົດເຫຼົ່ານີ້ສະຫນອງຄອມພິວເຕີ້ serverless, auto-scaling, ແລະພຽງແຕ່ຈ່າຍຄ່າສິ່ງທີ່ທ່ານໃຊ້ແທ້ໆ, ແຕ່ພວກເຂົາລັອກລູກຄ້າເຂົ້າໄປໃນຜະລິດຕະພັນທີ່ເປັນເຈົ້າຂອງຂອງພວກເຂົາ. ຢ່າງໃດກໍ່ຕາມ, ມີທາງເລືອກທີ່ບໍ່ເສຍຄ່າແລະແຫຼ່ງເປີດສໍາລັບຄອມພິວເຕີ້ທີ່ບໍ່ມີເຄື່ອງແມ່ຂ່າຍ. ມັນເປັນມູນຄ່າບອກ:

• ເວທີ Apache OpenWhisk, ພັດທະນາໃນ incubator ໂດຍ IBM,
• ຟັງຊັນ Spring Cloud, ເປັນສ່ວນຫນຶ່ງຂອງລະບົບນິເວດ Spring Framework ທີ່ອຸດົມສົມບູນ, ເຊິ່ງຍັງສາມາດຖືກນໍາໃຊ້ເປັນ facade ສໍາລັບ AWS Lambda, Azure Functions ແລະ OpenWhisk,
• ໂຄງການ Fn, ສະຫນັບສະຫນູນໂດຍ Oracle.

ພວກມັນທັງຫມົດແມ່ນເປັນເອກະລາດຢ່າງສົມບູນຂອງເມຄ, ນັ້ນແມ່ນ, ພວກເຂົາສາມາດຕິດຕັ້ງຢູ່ໃນເມຄໃດກໍ່ຕາມ, ລວມທັງຂອງທ່ານເອງ, ສາທາລະນະຫຼືເອກະຊົນ, ແລະແນ່ນອນໃນ Exoscale.

ໂຄງການ Fn ເຮັດວຽກແນວໃດ

Fn ແມ່ນອີງໃສ່ Docker ຢ່າງສົມບູນ, ປະກອບດ້ວຍສອງອົງປະກອບຕົ້ນຕໍ:

• ໂຄງການ CLI ຖືກອອກແບບມາເພື່ອຈັດການທຸກດ້ານຂອງໂຄງສ້າງພື້ນຖານ Fn, ແລະພົວພັນກັບເຄື່ອງແມ່ຂ່າຍ Fn,
• ເຊີບເວີ Fn ຕົວຂອງມັນເອງເປັນແອັບພລິເຄຊັນປົກກະຕິທີ່ບັນຈຸຢູ່ໃນ Docker container.

ຟັງຊັນທີ່ໃຊ້ໃນ Fn ຍັງຖືກປະຕິບັດຢູ່ໃນຖັງແຍກຕ່າງຫາກ, ເຊິ່ງຊ່ວຍໃຫ້ທ່ານສາມາດສະຫນັບສະຫນູນພາສາການຂຽນໂປລແກລມຫຼາຍ, ຕົວຢ່າງ ... Clojure!

ອາກິວເມັນຟັງຊັນຖືກສົ່ງຜ່ານເຂົ້າມາດຕະຖານ (STDIN), ຜົນໄດ້ຮັບຖືກຂຽນເປັນຜົນຜະລິດມາດຕະຖານ (STDOUT). ຖ້າການໂຕ້ຖຽງຫຼືຄ່າກັບຄືນບໍ່ແມ່ນຄ່າງ່າຍດາຍ (ເຊັ່ນວັດຖຸ JSON), ພວກເຂົາສາມາດຖືກແປງໂດຍໃຊ້ຊັ້ນ abstraction ສະຫນອງໃຫ້ໂດຍ Fn ຕົວຂອງມັນເອງໃນຮູບແບບຂອງ Function Development Kit (FDK).

ເພື່ອຄວາມສະດວກ, ຊຸດແມ່ແບບໃນຕົວແມ່ນໄດ້ຖືກສະເຫນີເພື່ອອໍານວຍຄວາມສະດວກໃນການນໍາໃຊ້ FaaS ໃນບັນຊີລາຍຊື່ຢ່າງກວ້າງຂວາງຂອງພາສາທີ່ແຕກຕ່າງກັນແລະສະບັບຂອງເຂົາເຈົ້າ (Go, ສະບັບທີ່ແຕກຕ່າງກັນຂອງ Java, Python, ແລະອື່ນໆ).

ການສ້າງ FaaS ແມ່ນງ່າຍໂດຍປະຕິບັດຕາມແຜນວາດນີ້:

• ການນຳໃຊ້ຟັງຊັນໂດຍໃຊ້ Fn CLI: ໄຟລ໌ການຕັ້ງຄ່າແອັບພລິເຄຊັນສຳລັບ Fn ແມ່ນສ້າງຂຶ້ນໂດຍອີງໃສ່ແມ່ແບບທີ່ເລືອກ.
• ພວກເຮົາມ້ວນຫນ້າທີ່ຂອງພວກເຮົາເອງ, ອີກເທື່ອຫນຶ່ງໂດຍໃຊ້ CLI Fn: ຮູບພາບບັນຈຸຖືກຈັດໃສ່ໃນບ່ອນເກັບມ້ຽນທີ່ແນ່ນອນ, ຫຼັງຈາກນັ້ນເຄື່ອງແມ່ຂ່າຍໄດ້ຮັບການແຈ້ງເຕືອນກ່ຽວກັບການມີຢູ່ແລະການຈັດວາງຂອງຮູບພາບນີ້.

ຫຼັກການຂອງການສົ່ງມອບຫນ້າທີ່ໃຫ້ Fn

ການຕິດຕັ້ງແລະການທົດສອບທ້ອງຖິ່ນຂອງຫນ້າທີ່ serverless

ເລີ່ມຕົ້ນດ້ວຍການຕິດຕັ້ງ Fn ໃນເຄື່ອງທ້ອງຖິ່ນ. ກ່ອນອື່ນໝົດ, ພວກເຮົາຕິດຕັ້ງ Docker, ຕາມທີ່ Fn ຮຽກຮ້ອງ. ນີ້ສົມມຸດວ່າພວກເຮົາຢູ່ໃນ Debian/Ubuntu:

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

ຫຼືໃຊ້ຕົວຈັດການຊຸດ / Docker build ຕາມລະບົບຂອງເຈົ້າ. ຫຼັງຈາກນັ້ນ, ທ່ານສາມາດໄປໂດຍກົງກັບການຕິດຕັ້ງ Fn CLI. ສໍາລັບຕົວຢ່າງ, ການນໍາໃຊ້ curl:

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

ຖ້າທ່ານຢູ່ໃນ OSX ທີ່ມີ Homebrew ຕິດຕັ້ງ, ທ່ານສາມາດໄປທາງອື່ນ:

$ 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

ດຽວນີ້ພວກເຮົາພ້ອມແລ້ວທີ່ຈະນຳໃຊ້ໜ້າທີ່ຂອງພວກເຮົາໃນເບື້ອງຕົ້ນໂດຍໃຊ້ CLI. ເພື່ອຄວາມງ່າຍດາຍ, ພວກເຮົາຈະໃຊ້ສະພາບແວດລ້ອມການເປີດຕົວໃນຕົວ, ເຊັ່ນ: Node:

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

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

ໄດເລກະທໍລີໃຫມ່ຈະຖືກສ້າງຂື້ນ hellonode ເພື່ອພັດທະນາຟັງຊັນ Fn ຂອງພວກເຮົາກັບບາງໄຟລ໌ການຕັ້ງຄ່າພື້ນຖານ. ພາຍໃນໄດເລກະທໍລີທີ່ສ້າງໃຫມ່, ທ່ານສາມາດສ້າງແອັບພລິເຄຊັນຂອງທ່ານປະຕິບັດຕາມມາດຕະຖານຂອງພາສາຫຼືເວລາແລ່ນທີ່ທ່ານເລືອກ:

# Каталог с 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 ສ້າງໂຄງສ້າງໂຄງການເບື້ອງຕົ້ນ, ສ້າງໄຟລ໌ func.yaml, ປະກອບດ້ວຍການຕັ້ງຄ່າທີ່ຈໍາເປັນສໍາລັບ Fn, ແລະກໍານົດແມ່ແບບສໍາລັບລະຫັດໃນພາສາທີ່ທ່ານເລືອກ.

ໃນກໍລະນີຂອງ Node runtime, ນີ້ຫມາຍຄວາມວ່າ:

$ 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}
})

ຕອນນີ້ພວກເຮົາຈະທົດສອບຟັງຊັນຂອງພວກເຮົາຢູ່ໃນທ້ອງຖິ່ນຢ່າງໄວວາເພື່ອເບິ່ງວ່າທຸກຢ່າງເຮັດວຽກແນວໃດ.

ທໍາອິດ, ພວກເຮົາຈະເລີ່ມຕົ້ນເຄື່ອງແມ່ຂ່າຍ Fn. ດັ່ງທີ່ໄດ້ກ່າວມາແລ້ວ, ເຄື່ອງແມ່ຂ່າຍ Fn ແມ່ນ Docker container, ດັ່ງນັ້ນ, ຫຼັງຈາກການເລີ່ມຕົ້ນ, ມັນຈະໄປແລະເອົາຮູບພາບຈາກ Docker registry.

$ 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

ເພື່ອປະຕິບັດຫນ້າທີ່ຂອງພວກເຮົາ, ມັນຕ້ອງໄດ້ຮັບການ "ມ້ວນອອກ". ນີ້ຮຽກຮ້ອງໃຫ້ມີ имя приложения: ໃນ Fn, ທຸກໆແອັບພລິເຄຊັນຕ້ອງຖືກລະບຸເປັນ namespaces ສໍາລັບຟັງຊັນທີ່ກ່ຽວຂ້ອງ.

Fn CLI ຈະຊອກຫາໄຟລ໌ func.yaml ໃນໄດເລກະທໍລີປະຈຸບັນທີ່ຈະຖືກນໍາໃຊ້ເພື່ອກໍາຫນົດຄ່າຟັງຊັນ. ດັ່ງນັ້ນທໍາອິດທ່ານຈໍາເປັນຕ້ອງໄປໄດເລກະທໍລີຂອງພວກເຮົາ 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

ດັ່ງທີ່ເຈົ້າສາມາດເຫັນໄດ້ຈາກຜົນຜະລິດຄໍາສັ່ງ, ຮູບພາບບັນຈຸ Docker ໃຫມ່ແມ່ນຖືກສ້າງຂຶ້ນທີ່ມີຫນ້າທີ່ຂອງພວກເຮົາ. ຟັງຊັນແມ່ນພ້ອມທີ່ຈະຖືກເອີ້ນ, ແລະພວກເຮົາມີສອງວິທີທີ່ຈະເຮັດມັນ:

• ໃຊ້ຄໍາສັ່ງ Fn invoke
• ໂທໂດຍກົງຜ່ານ http

ທ້າທາຍ invoke ຜ່ານ Fn ມັນພຽງແຕ່ emulates ເຮັດວຽກຜ່ານ HTTP ສໍາລັບການທົດສອບ, ເຊິ່ງສະດວກສໍາລັບການທົດສອບໄວ:

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

{"message":"Hello World"}

ເພື່ອໂທຫາຫນ້າທີ່ໂດຍກົງ, ທ່ານຈໍາເປັນຕ້ອງຮູ້ URL ເຕັມ:

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

{"message":"Hello World"}

ເຊີບເວີ Fn ເປີດເຜີຍຟັງຊັນຂອງມັນຢູ່ໃນພອດ 8080 ແລະ URL ຟັງຊັນປະກົດວ່າກົງກັບຮູບແບບ t/app/function, ແຕ່ບໍ່ສົມບູນ. ຜ່ານ HTTP, ຟັງຊັນບໍ່ຖືກເອີ້ນໂດຍກົງ, ແຕ່ຜ່ານອັນທີ່ເອີ້ນວ່າ trigger, ເຊິ່ງ, ອີງຕາມຊື່ຂອງມັນ, "ເລີ່ມຕົ້ນ" ໂທຫາຫນ້າທີ່. Triggers ຖືກກໍານົດໄວ້ໃນ `func.yml ໂຄງການ:

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 триггера

ພວກເຮົາສາມາດປ່ຽນຊື່ຕົວກະຕຸ້ນໃຫ້ກົງກັບຊື່ຟັງຊັນ, ນີ້ຈະເຮັດໃຫ້ທຸກສິ່ງທຸກຢ່າງງ່າຍດາຍ:

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

ຫຼັງຈາກນັ້ນ, ພວກເຮົາເລີ່ມຕົ້ນການຈັດສົ່ງຟັງຊັນອີກເທື່ອຫນຶ່ງແລະໂທຫາມັນຈາກ trigger ໃຫມ່:

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

{"message":"Hello World"}

ທຸກຢ່າງກຳລັງເຮັດວຽກ! ມັນເຖິງເວລາແລ້ວທີ່ຈະກ້າວໄປສູ່ການທົດລອງເຕັມຮູບແບບ ແລະເຜີຍແຜ່ FaaS ຂອງພວກເຮົາໃນເຊີບເວີ!

ການຕິດຕັ້ງບໍລິການຟັງຊັນເຊີບເວີໃນໂຄງສ້າງພື້ນຖານຂອງທ່ານເອງ

ຂໍໃຫ້ຕິດຕັ້ງເຄື່ອງ virtual ຢ່າງໄວວາໂດຍໃຊ້ Exoscale CLI. ຖ້າທ່ານຍັງບໍ່ໄດ້ຕັ້ງມັນເທື່ອ, ທ່ານສາມາດນໍາໃຊ້ ຄູ່ມືເລີ່ມຕົ້ນໄວຂອງພວກເຮົາ. ນີ້ແມ່ນເຄື່ອງມືທີ່ເຢັນທີ່ຈະເພີ່ມຜົນຜະລິດຂອງທ່ານຫຼາຍຂຶ້ນ. ຢ່າລືມວ່າເຈົ້າຕ້ອງຕັ້ງຄ່າກົດລະບຽບເພື່ອເປີດພອດ 8080 ໃນກຸ່ມຄວາມປອດໄພ! ຄໍາສັ່ງຕໍ່ໄປນີ້ຈະເປີດຕົວເຄື່ອງ virtual ທີ່ສະອາດ, ພ້ອມທີ່ຈະເປັນເຈົ້າພາບຫນ້າທີ່ຂອງພວກເຮົາ:

$ 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

ຈາກນັ້ນທ່ານສາມາດ ssh ເຂົ້າໄປໃນເຄື່ອງ virtual ແລະຕິດຕັ້ງເຄື່ອງແມ່ຂ່າຍ Fn ຫ່າງໄກສອກຫຼີກ:

$ 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)

ຫຼັງຈາກນັ້ນ, ຕິດຕັ້ງ Docker ແລະເຄື່ອງແມ່ຂ່າຍ Fn ໃນທາງດຽວກັນກັບທີ່ໄດ້ເຮັດແລ້ວໃນເຄື່ອງທ້ອງຖິ່ນ, ເລີ່ມຕົ້ນເຄື່ອງແມ່ຂ່າຍ:

$ 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 ພ້ອມຮັບຟັງຊັນ! ສໍາລັບການໂອນຫນ້າທີ່ເປົ້າຫມາຍໄປຫາເຄື່ອງແມ່ຂ່າຍຫ່າງໄກສອກຫຼີກ, ພວກເຮົາຈະໃຊ້ຄໍາສັ່ງ deploy ຈາກຄອມພິວເຕີທ້ອງຖິ່ນໂດຍການລະເວັ້ນທຸງ --local.

ນອກຈາກນັ້ນ, Fn ຮຽກຮ້ອງໃຫ້ທ່ານລະບຸສະຖານທີ່ຂອງເຄື່ອງແມ່ຂ່າຍ Fn ແລະການລົງທະບຽນ Docker. ທາງເລືອກເຫຼົ່ານີ້ສາມາດຖືກຕັ້ງຄ່າຜ່ານຕົວແປສະພາບແວດລ້ອມ FN_API_URL и FN_REGISTRY ຕາມລໍາດັບ, ແຕ່ຍັງສະເຫນີວິທີການທີ່ສະດວກກວ່າໃນການຄຸ້ມຄອງການສ້າງແລະການຄຸ້ມຄອງການຕັ້ງຄ່າສໍາລັບການນໍາໃຊ້ໄດ້ຢ່າງງ່າຍດາຍ.

ໃນເງື່ອນໄຂ Fn, ການຕັ້ງຄ່າສໍາລັບການນໍາໃຊ້ແມ່ນເອີ້ນວ່າ context. ຄໍາສັ່ງຕໍ່ໄປນີ້ຈະສ້າງບໍລິບົດ:

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

ທ່ານສາມາດເບິ່ງສະພາບການທີ່ມີຢູ່ເຊັ່ນນີ້:

$ fn list contexts

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

ແລະສະຫຼັບກັບສະພາບການທີ່ຫາກໍ່ສ້າງແບບນີ້:

 $ fn use context exoscale

 Now using context: exoscale

ຈາກນີ້, ການຈັດສົ່ງຄຸນສົມບັດ Fn ຈະດາວໂຫລດຮູບພາບ Docker ໂດຍໃຊ້ບັນຊີ DockerHub ທີ່ເລືອກ (ໃນກໍລະນີຂອງຂ້ອຍ - nfrankel), ແລະຫຼັງຈາກນັ້ນແຈ້ງໃຫ້ເຄື່ອງແມ່ຂ່າຍຫ່າງໄກສອກຫຼີກ (ໃນຕົວຢ່າງນີ້ - http://185.19.30.175:8080) ກ່ຽວກັບສະຖານທີ່ແລະສະບັບຂອງຮູບພາບຫລ້າສຸດທີ່ມີຫນ້າທີ່ຂອງທ່ານ.

$ 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 .

ສຸດທ້າຍ:

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

{"message":"Hello World"}

Function Lifecycle ໃນ Fn-Based Serverless Computing

ຂໍ້ໄດ້ປຽບຂອງຄອມພິວເຕີ້ serverless ຢູ່ໃນຄວາມສາມາດຂອງທ່ານເອງ

ຄອມພິວເຕີທີ່ບໍ່ມີເຊີບເວີແມ່ນເປັນການແກ້ໄຂທີ່ສະດວກສໍາລັບການຈັດຕັ້ງປະຕິບັດພາກສ່ວນທີ່ເປັນເອກະລາດຢ່າງໄວວາຂອງແອັບພລິເຄຊັນທີ່ພົວພັນກັບແອັບພລິເຄຊັນ ຫຼືບໍລິການຈຸລະພາກທີ່ສັບສົນຫຼາຍ.

ນີ້ມັກຈະເປັນຍ້ອນຄ່າໃຊ້ຈ່າຍທີ່ເຊື່ອງໄວ້ຂອງການລັອກຢູ່ໃນຜູ້ຂາຍທີ່ເລືອກ, ເຊິ່ງ, ອີງຕາມກໍລະນີການນໍາໃຊ້ສະເພາະແລະປະລິມານ, ສາມາດນໍາໄປສູ່ຄ່າໃຊ້ຈ່າຍທີ່ສູງຂຶ້ນແລະຫຼຸດຜ່ອນຄວາມຍືດຫຍຸ່ນໃນອະນາຄົດ.

ສະຖາປັດຕະຍະກໍາຟັງຫຼາຍຄລາວແລະປະສົມຍັງທົນທຸກໃນກໍລະນີນີ້, ເພາະວ່າເຈົ້າສາມາດຊອກຫາຕົວເອງໄດ້ງ່າຍໃນສະຖານະການທີ່ເຈົ້າຢາກໃຊ້ຄອມພິວເຕີ້ທີ່ບໍ່ມີເຄື່ອງແມ່ຂ່າຍ, ແຕ່ເນື່ອງຈາກນະໂຍບາຍຂອງບໍລິສັດມັນອາດຈະເປັນໄປບໍ່ໄດ້.

Fn ແມ່ນຂ້ອນຂ້າງງ່າຍທີ່ຈະໃຊ້ແລະສາມາດສະຫນອງການໂຕ້ຕອບ FaaS ເກືອບດຽວກັນ, ມີຄ່າໃຊ້ຈ່າຍພຽງເລັກນ້ອຍ. ມັນກໍາຈັດການລັອກຂອງຜູ້ຂາຍໃດໆແລະສາມາດຕິດຕັ້ງຢູ່ໃນທ້ອງຖິ່ນຫຼືໃນຜູ້ໃຫ້ບໍລິການແກ້ໄຂເມຄທີ່ສະດວກສະບາຍທີ່ທ່ານເລືອກ. ນອກນັ້ນຍັງມີອິດສະລະໃນການເລືອກພາສາການຂຽນໂປຼແກຼມ.

ບົດຄວາມນີ້ກວມເອົາພຽງແຕ່ພື້ນຖານຂອງ Fn, ແຕ່ການສ້າງ runtime ຂອງທ່ານເອງແມ່ນຂ້ອນຂ້າງງ່າຍດາຍ, ແລະສະຖາປັດຕະຍະພາບໂດຍລວມສາມາດຖືກນໍາໃຊ້ຢ່າງກວ້າງຂວາງຫຼາຍໂດຍໃຊ້ Fn load balancer, ຫຼືໂດຍການວາງ Fn ຢູ່ຫລັງ proxy ສໍາລັບການປົກປ້ອງ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com