🥇Կառուցում ենք մեր սեփական առանց սերվերի հիման վրա Fn

Առանց սերվերի հաշվարկ ամպային հաշվարկի ամենահայտնի միտումներից մեկն է: Գործառնական հիմնական սկզբունքն այն է, որ ենթակառուցվածքը DevOps-ի մտահոգությունը չէ, այլ ծառայություն մատուցողի: Ռեսուրսների մասշտաբը ավտոմատ կերպով հարմարվում է բեռնվածությանը և ունի փոփոխման բարձր արագություն:

Մեկ այլ ընդհանուր առանձնահատկություն է կոդը նվազագույնի հասցնելու և կենտրոնացնելու միտումը, այդ իսկ պատճառով առանց սերվերի հաշվարկը երբեմն կոչվում է գործառույթ որպես ծառայություն (FaaS):

Պատմականորեն, առաջին ամպային մատակարարը, որն առաջարկել է FaaS AWS Lambda-ով, Amazon-ն էր, այստեղից էլ՝ անվանումը: Այլ ամպային ծառայություններ մատուցողներ նույնպես առաջարկում են նմանատիպեր.

Ամպային գործառույթներ Google-ից
Azure գործառույթները Microsoft-ից

Այս բոլոր ընկերությունները տրամադրում են առանց սերվերի հաշվարկներ, ավտոմատ մասշտաբավորում և վճարում են միայն այն բանի համար, ինչ դուք իրականում օգտագործում եք, բայց նրանք փակում են հաճախորդներին իրենց սեփական արտադրանքի մեջ: Այնուամենայնիվ, կան անվճար և բաց կոդով այլընտրանքներ առանց սերվերի հաշվարկման համար: Հարկ է նշել.

Հարթակ Apache OpenWhiskIBM-ի կողմից մշակված ինկուբատորում,
Գարնանային ամպի գործառույթներ, որպես բավականին հարուստ Spring Framework էկոհամակարգի մի մաս, որը կարող է օգտագործվել նաև որպես ֆասադ AWS Lambda-ի, Azure Functions-ի և OpenWhisk-ի համար,
Նախագիծ FnOracle-ի աջակցությամբ:

Դրանք բոլորն ամբողջովին անկախ են ամպերից, այսինքն՝ կարող են տեղադրվել ցանկացած ամպի մեջ՝ ներառյալ ձեր սեփական, հանրային կամ մասնավոր, և իհարկե Exoscale-ում։

Ինչպես է աշխատում Fn նախագիծը

Fn-ն ամբողջությամբ հիմնված է Docker-ի վրա, բաղկացած է երկու հիմնական բաղադրիչից.

CLI ծրագիր, որը նախատեսված է Fn ենթակառուցվածքի բոլոր ասպեկտները կառավարելու և Fn սերվերի հետ փոխազդելու համար,
Fn սերվերն ինքնին սովորական հավելված է, որը փաթեթավորված է Docker կոնտեյներով:

Fn-ում տեղաբաշխված գործառույթները նույնպես կատարվում են առանձին կոնտեյներներում, ինչը թույլ է տալիս աջակցել ծրագրավորման բազմաթիվ լեզուների, օրինակ... Clojure!

Ֆունկցիայի փաստարկները փոխանցվում են ստանդարտ մուտքագրմանը (STDIN), արդյունքները գրվում են ստանդարտ ելքի վրա (STDOUT): Եթե արգումենտները կամ վերադարձվող արժեքները պարզ արժեքներ չեն (օրինակ՝ JSON օբյեկտ), դրանք կարող են փոխակերպվել՝ օգտագործելով աբստրակցիոն շերտը, որը տրամադրվում է հենց Fn-ի կողմից՝ Ֆունկցիայի զարգացման հավաքածուի (FDK) տեսքով:

Հարմարության համար առաջարկվում են կաղապարների ներկառուցված հավաքածուներ՝ հեշտացնելու FaaS-ի տեղակայումը տարբեր լեզուների և դրանց տարբերակների ընդարձակ ցանկում (Go, Java, Python-ի տարբեր տարբերակներ և այլն):

FaaS-ի ստեղծումը հեշտ է՝ հետևելով այս դիագրամին.

Գործառույթի տեղակայում Fn CLI-ի միջոցով. ընտրված ձևանմուշի հիման վրա ստեղծվում է հավելվածի կազմաձևման ֆայլ Fn-ի համար:
Մենք բացում ենք մեր սեփական ֆունկցիան՝ կրկին օգտագործելով CLI Fn. կոնտեյների պատկերը տեղադրվում է որոշակի պահոցում, որից հետո սերվերը ծանուցվում է այս պատկերի գոյության և տեղադրման մասին։

Fn-ին գործառույթներ մատուցելու սկզբունքը

Տեղական տեղադրում և առանց սերվերի գործառույթների փորձարկում

Եկեք սկսենք տեղադրել 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 կոնտեյներ է, հետևաբար գործարկումից հետո այն կգնա և կվերցնի պատկերը 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

Մեր գործառույթը գործարկելու համար այն պետք է «գլորվի»: Սա պահանջում է имя приложенияFn-ում բոլոր հավելվածները պետք է նշվեն որպես հարակից գործառույթների անունների տարածքներ:

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-ի միջոցով այն պարզապես ընդօրինակում է աշխատանքը 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-ի միջոցով ֆունկցիան կանչվում է ոչ թե ուղղակիորեն, այլ այսպես կոչված ձգանչի միջոցով, որն, ըստ իր անվան, «սկսում է» ֆունկցիայի կանչը։ Գործարկիչները սահմանվում են `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    # совпадает с именем функции

Այնուհետև մենք նորից գործարկում ենք գործառույթի առաքումը և այն կանչում նոր ձգանից.

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

{"message":"Hello World"}

Ամեն ինչ աշխատում է! Ժամանակն է անցնել լայնածավալ փորձերի և սերվերում հրապարակել մեր FaaS-ը:

Անսերվերի գործառույթների ծառայությունների տեղադրում ձեր սեփական ենթակառուցվածքում

Եկեք արագ տեղադրենք վիրտուալ մեքենա՝ օգտագործելով Exoscale CLI: Եթե դեռ չեք կարգավորել այն, կարող եք օգտագործել մեր արագ մեկնարկի ուղեցույցը. Սա հիանալի գործիք է, որն էլ ավելի կբարձրացնի ձեր արտադրողականությունը: Մի մոռացեք, որ անվտանգության խմբում 8080 նավահանգիստը բացելու համար անհրաժեշտ է կարգավորել կանոն: Հետևյալ հրամանները կգործարկեն մաքուր վիրտուալ մեքենա, որը պատրաստ է հյուրընկալելու մեր գործառույթները.

$ 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 մտցնել վիրտուալ մեքենա և տեղադրել հեռավոր 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"}

Գործառույթների կյանքի ցիկլը Fn-ի վրա հիմնված առանց սերվերի հաշվարկման մեջ

Առանց սերվերի հաշվարկման առավելությունները ձեր սեփական հզորությամբ

Առանց սերվերի հաշվարկը հարմար լուծում է հավելվածի անկախ մասերի արագ իրականացման համար, որոնք փոխազդում են ավելի բարդ հավելվածների կամ միկրոծառայությունների հետ:

Սա հաճախ պայմանավորված է ընտրված վաճառողին կողպելու թաքնված արժեքով, որը, կախված օգտագործման կոնկրետ դեպքից և ծավալից, կարող է հետագայում հանգեցնել ավելի մեծ ծախսերի և ճկունության նվազմանը:

Բազմաամպային և հիբրիդային ամպային ճարտարապետությունները նույնպես տուժում են այս դեպքում, քանի որ հեշտությամբ կարող եք հայտնվել այնպիսի իրավիճակում, երբ կցանկանայիք օգտագործել առանց սերվերի հաշվարկներ, բայց կորպորատիվ քաղաքականության պատճառով դա հնարավոր չէ:

Fn-ը բավականին հեշտ է օգտագործել և կարող է ապահովել գրեթե նույն FaaS ինտերֆեյսը, փոքր ծախսերով: Այն վերացնում է ցանկացած վաճառողի արգելափակումը և կարող է տեղադրվել տեղում կամ ձեր ընտրած ցանկացած հարմար ամպային լուծումների մատակարարում: Ազատություն կա նաև ծրագրավորման լեզվի ընտրության հարցում։

Այս հոդվածն ընդգրկում է միայն Fn-ի հիմունքները, բայց ձեր սեփական գործարկման ժամանակի ստեղծումը բավականին պարզ է, և ընդհանուր ճարտարապետությունը կարող է ավելի լայն տարածվել՝ օգտագործելով Fn բեռի հավասարակշռիչը, կամ տեղադրելով Fn-ը պաշտպանված անձի հետևում:

Source: www.habr.com

Fn-ի վրա հիմնված մեր սեփական առանց սերվերի կառուցում

Ինչպես է աշխատում Fn նախագիծը

Տեղական տեղադրում և առանց սերվերի գործառույթների փորձարկում

Անսերվերի գործառույթների ծառայությունների տեղադրում ձեր սեփական ենթակառուցվածքում

Առանց սերվերի հաշվարկման առավելությունները ձեր սեփական հզորությամբ

Добавить комментарий Չեղարկել պատասխանել