ay isa sa mga pinakakilalang uso sa cloud computing. Ang pangunahing prinsipyo ng pagpapatakbo ay ang imprastraktura ay hindi ang alalahanin ng DevOps, ngunit ng service provider. Awtomatikong nagsasaayos ang pag-scale ng mapagkukunan sa pag-load at may mataas na rate ng pagbabago.
Ang isa pang karaniwang tampok ay ang pagkahilig sa pag-minimize at pagtutok ng code, kaya naman kung minsan ang serverless computing ay tinatawag na function bilang isang serbisyo (FaaS).
Sa kasaysayan, ang unang cloud provider na nag-aalok ng FaaS sa AWS Lambda ay Amazon, kaya ang pangalan. Ang iba pang mga cloud service provider ay nag-aalok din ng mga katulad:
- Cloud Functions mula sa Google
- Azure Functions mula sa Microsoft
Ang lahat ng mga kumpanyang ito ay nagbibigay ng serverless computing, auto-scaling, at nagbabayad lamang para sa kung ano ang aktwal mong ginagamit, ngunit ikinukulong nila ang mga customer sa kanilang pagmamay-ari na produkto. Gayunpaman, may mga libre at open source na alternatibo para sa serverless computing. Ito ay nagkakahalaga ng pagpuna:
- Platform , na binuo sa isang incubator ng IBM,
- , bilang bahagi ng medyo mayamang Spring Framework ecosystem, na maaari ding gamitin bilang facade para sa AWS Lambda, Azure Functions at OpenWhisk,
- , suportado ng Oracle.
Ang lahat ng mga ito ay ganap na independyente sa mga ulap, iyon ay, maaari silang mai-install sa anumang ulap, kabilang ang iyong sarili, pampubliko o pribado, at siyempre sa Exoscale.
Paano gumagana ang proyekto ng Fn
Ang Fn ay ganap na nakabatay sa Docker, ay binubuo ng dalawang pangunahing bahagi:
- CLI program na idinisenyo upang pamahalaan ang lahat ng aspeto ng imprastraktura ng Fn, at nakikipag-ugnayan sa Fn server,
- Ang Fn server mismo ay isang regular na application na nakabalot sa isang lalagyan ng Docker.
Ang mga function na naka-deploy sa Fn ay isinasagawa din sa magkahiwalay na mga lalagyan, na nagbibigay-daan sa iyo upang suportahan ang maraming mga programming language, halimbawa... Clojure!
Ang mga argumento ng function ay ipinapasa sa karaniwang input (STDIN), ang mga resulta ay nakasulat sa karaniwang output (STDOUT). Kung ang mga argumento o return value ay hindi simpleng value (tulad ng JSON object), maaari silang ma-convert gamit ang abstraction layer na ibinigay ng Fn mismo sa anyo ng Function Development Kit (FDK).
Para sa kaginhawahan, ang mga built-in na set ng mga template ay inaalok upang mapadali ang pag-deploy ng FaaS sa isang malawak na listahan ng iba't ibang mga wika at ang kanilang mga bersyon (Go, iba't ibang bersyon ng Java, Python, atbp.).
Ang paglikha ng FaaS ay madali sa pamamagitan ng pagsunod sa diagram na ito:
- Ang pag-deploy ng function gamit ang Fn CLI: isang application configuration file para sa Fn ay ginawa batay sa napiling template.
- Inilunsad namin ang aming sariling pag-andar, muli gamit ang CLI Fn: ang imahe ng lalagyan ay inilalagay sa isang tiyak na imbakan, pagkatapos ay aabisuhan ang server ng pagkakaroon at paglalagay ng larawang ito.
Ang prinsipyo ng paghahatid ng mga function sa Fn
Lokal na pag-install at pagsubok ng mga walang server na function
Simulan natin ang pag-install ng Fn sa lokal na makina. Una, naka-install ang Docker, ayon sa hinihingi ng Fn. Sa pag-aakalang nasa Debian/Ubuntu tayo:
$ sudo apt-get update
$ sudo apt-get install docker.ioO gumamit ng package manager/Docker build ayon sa iyong system. Pagkatapos ay maaari kang dumiretso sa pag-install ng Fn CLI. Halimbawa, gamit ang curl:
$ curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | shKung ikaw ay nasa OSX na may naka-install na Homebrew, maaari kang pumunta sa ibang paraan:
$ 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.7MBHanda na kami ngayon na unang i-deploy ang aming function gamit ang CLI. Para sa pagiging simple, gagamit kami ng built-in na kapaligiran sa paglulunsad, gaya ng Node:
$ fn init --runtime node --trigger http hellonode
Creating function at: /hellonode
Function boilerplate generated.
func.yaml created.Isang bagong direktoryo ang gagawin hellonode upang higit pang mabuo ang aming Fn function na may ilang pangunahing configuration file. Sa loob ng bagong likhang direktoryo, maaari kang lumikha ng iyong aplikasyon ayon sa mga pamantayan ng iyong napiling wika o runtime:
# Каталог с 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.javaLumilikha ang Fn ng paunang istraktura ng proyekto, lumilikha ng isang file func.yaml, na naglalaman ng mga kinakailangang setting para sa Fn, at itinatakda ang template para sa code sa wikang iyong pinili.
Sa kaso ng runtime ng Node, nangangahulugan ito:
$ 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}
})Ngayon ay mabilis naming susubukan ang aming function nang lokal upang makita kung paano gumagana ang lahat.
Una, sisimulan natin ang Fn server. Tulad ng nabanggit na, ang Fn server ay isang lalagyan ng Docker, samakatuwid, pagkatapos ng pagsisimula, pupunta ito at kukunin ang imahe mula sa pagpapatala ng 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
668ce9ac0ed8d7cd59da49228bda62464e01bff2c0c60079542d24ac6070f8e5Upang patakbuhin ang aming function, dapat itong "ilunsad". Nangangailangan ito имя приложения: Sa Fn, ang lahat ng application ay dapat na tukuyin bilang mga namespace para sa mga nauugnay na function.
Hahanapin ng Fn CLI ang file func.yaml sa kasalukuyang direktoryo na gagamitin para i-configure ang function. Kaya kailangan mo munang pumunta sa aming direktoryo 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-triggerTulad ng nakikita mo mula sa output ng command, isang bagong Docker container na imahe ang nilikha na naglalaman ng aming function. Handa nang tawagan ang function, at mayroon kaming dalawang paraan para gawin ito:
- gamit ang Fn command
invoke - direktang tumatawag sa pamamagitan ng
http
Hamon invoke sa pamamagitan ng Fn ay ginagaya lamang nito ang trabaho sa pamamagitan ng HTTP para sa mga pagsubok, na maginhawa para sa mabilis na pagsubok:
$ fn invoke fnexo hellonode # вызываем функцию hellonode приложения fnexo
{"message":"Hello World"}Upang direktang tumawag sa isang function, kailangan mong malaman ang buong URL:
$ curl http://localhost:8080/t/fnexo/hellonode-trigger
{"message":"Hello World"}Inilalantad ng Fn server ang mga function nito sa port 8080 at lumilitaw na tumutugma ang URL ng function sa pattern t/app/function, ngunit hindi ganap. Sa pamamagitan ng HTTP, ang isang function ay hindi direktang tinatawag, ngunit sa pamamagitan ng isang tinatawag na trigger, na, ayon sa pangalan nito, "nagsisimula" sa function na tawag. Ang mga trigger ay tinukoy sa `func.yml proyekto:
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 триггераMaaari naming baguhin ang pangalan ng trigger upang tumugma sa pangalan ng function, ito ay gawing simple ang lahat:
triggers:
- name: hellonode-trigger
type: http
source: /hellonode # совпадает с именем функцииPagkatapos ay sisimulan naming ihatid muli ang function at tawagan ito mula sa isang bagong trigger:
$ fn deploy --app fnexo hellonode --local
$ curl http://localhost:8080/t/fnexo/hellonode
{"message":"Hello World"}Lahat ay gumagana! Oras na para lumipat sa mga full-scale na eksperimento at i-publish ang aming FaaS sa server!
Pag-install ng mga serbisyo ng walang server na function sa sarili mong imprastraktura
Mabilis tayong mag-install ng virtual machine gamit ang Exoscale CLI. Kung hindi mo pa ito nase-set up, maaari mong gamitin . Ito ay isang cool na tool na magpapataas ng iyong pagiging produktibo. Huwag kalimutan na kailangan mong i-configure ang isang panuntunan upang buksan ang port 8080 sa Security Group! Ang mga sumusunod na command ay maglulunsad ng malinis na virtual machine, na handang i-host ang aming mga function:
$ 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-securitygroupPagkatapos ay maaari mong ssh sa virtual machine at i-install ang remote Fn server:
$ 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)Pagkatapos ay i-install ang Docker at ang Fn server sa parehong paraan tulad ng ginawa na sa lokal na makina, simulan ang 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.643Handa na ang Fn na tumanggap ng mga function! Para sa naka-target na paglipat ng mga function sa isang malayong server, gagamitin namin ang command deploy mula sa lokal na computer sa pamamagitan ng pag-alis ng bandila --local.
Bilang karagdagan, hinihiling sa iyo ng Fn na tukuyin ang lokasyon ng Fn server at Docker registry. Maaaring itakda ang mga opsyong ito sa pamamagitan ng mga variable ng kapaligiran FN_API_URL и FN_REGISTRY ayon sa pagkakabanggit, ngunit nag-aalok din ng mas maginhawang paraan upang madaling pamahalaan ang paglikha at pamamahala ng mga pagsasaayos para sa pag-deploy.
Sa mga terminong Fn, tinatawag ang configuration para sa deployment context. Ang sumusunod na utos ay lilikha ng konteksto:
$ fn create context exoscale --provider default --api-url http://185.19.30.175:8080 --registry nfrankelMaaari mong tingnan ang mga magagamit na konteksto tulad nito:
$ fn list contexts
CURRENT NAME PROVIDER API URL REGISTRY
default default http://localhost:8080/
exoscale default http://185.19.30.175:8080 nfrankel
At lumipat sa konteksto na kakalikha lang tulad nito:
$ fn use context exoscale
Now using context: exoscaleMula dito, ang paghahatid ng tampok na Fn ay magda-download ng mga larawan ng Docker gamit ang napiling DockerHub account (sa aking kaso - nfrankel), at pagkatapos ay abisuhan ang malayong server (sa halimbawang ito - http://185.19.30.175:8080) tungkol sa lokasyon at bersyon ng pinakabagong larawan na naglalaman ng iyong function.
$ 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 .Sa wakas:
$ curl http://185.19.30.175:8080/t/fnexo/hellonode
{"message":"Hello World"}
Function Lifecycle sa Fn-Based Serverless Computing
Mga kalamangan ng serverless computing sa sarili mong kapasidad
Ang serverless computing ay isang maginhawang solusyon para sa mabilis na pagpapatupad ng mga independiyenteng bahagi ng isang application na nakikipag-ugnayan sa mas kumplikadong mga application o microservice.
Kadalasan ito ay dahil sa nakatagong halaga ng pag-lock in sa napiling vendor, na, depende sa partikular na kaso at dami ng paggamit, ay maaaring humantong sa mas mataas na gastos at nabawasan ang flexibility sa hinaharap.
Ang mga multi-cloud at hybrid na arkitektura ng cloud ay nagdurusa din sa kasong ito, dahil madali mong mahahanap ang iyong sarili sa isang sitwasyon kung saan gusto mong gumamit ng serverless computing, ngunit dahil sa mga patakaran ng korporasyon ay maaaring hindi ito posible.
Ang Fn ay medyo madaling gamitin at maaaring magbigay ng halos parehong interface ng FaaS, na may maliit na overhead. Tinatanggal nito ang anumang lock-in ng vendor at maaaring mai-install nang lokal o sa anumang maginhawang provider ng solusyon sa ulap na gusto mo. May kalayaan din sa pagpili ng programming language.
Ang artikulong ito ay sumasaklaw lamang sa mga pangunahing kaalaman ng Fn, ngunit ang paggawa ng sarili mong runtime ay medyo simple, at ang pangkalahatang arkitektura ay maaaring i-deploy nang mas malawak gamit ang isang Fn load balancer, o sa pamamagitan ng paglalagay ng Fn sa likod ng isang proxy para sa proteksyon.
Pinagmulan: www.habr.com