ProHoster > Blog > Administrazioa > Fn oinarritutako gure zerbitzaririk gabekoa eraikitzea

Fn oinarritutako gure zerbitzaririk gabekoa eraikitzea

Fn oinarritutako gure zerbitzaririk gabekoa eraikitzea

Zerbitzaririk gabeko informatika hodeiko informatikaren joera nabarmenetako bat da. Oinarrizko funtzionamendu-printzipioa da azpiegitura ez dela DevOps-en ardura, zerbitzu hornitzailearena baizik. Baliabideen eskalatzea automatikoki doitzen da kargara eta aldaketa-tasa handia du.

Beste ezaugarri komun bat kodea minimizatzeko eta bideratzeko joera da, horregatik zerbitzaririk gabeko konputazioa zerbitzu gisa funtzionamendua (FaaS) deitzen zaio batzuetan.

Historikoki, AWS Lambda-rekin FaaS eskaintzen duen lehen hodeiko hornitzailea Amazon izan zen, hortik izena. Beste hodeiko zerbitzu hornitzaileek ere antzekoak eskaintzen dituzte:

  • Google-ren Cloud Functions
  • Microsoft-en Azure Functions

Enpresa hauek guztiek zerbitzaririk gabeko informatika, eskalatze automatikoa eskaintzen dute eta benetan erabiltzen duzunagatik bakarrik ordaintzen dute, baina bezeroak beren produktu jabedunean blokeatzen dituzte. Hala ere, badaude doako eta kode irekiko alternatibak zerbitzaririk gabeko konputaziorako. Aipatzekoa da:

  • plataforma Apache OpenWhisk, IBMk inkubagailu batean garatua,
  • Spring Cloud Funtzioak, Spring Framework ekosistema nahiko aberats baten parte gisa, AWS Lambda, Azure Functions eta OpenWhisk-en fatxada gisa ere erabil daitekeena,
  • Proiektua Fn, Oracle-k lagunduta.

Guztiak hodeietatik guztiz independenteak dira, hau da, edozein hodeitan instala daitezke, zurea, publikoa edo pribatua barne, eta noski Exoscale-n.

Fn proiektuak nola funtzionatzen duen

Fn Docker-en oinarritzen da guztiz, bi osagai nagusi ditu:

  • Fn azpiegituraren alderdi guztiak kudeatzeko eta Fn zerbitzariarekin elkarreragiten duen CLI programa.
  • Fn zerbitzaria bera Docker edukiontzi batean bildutako ohiko aplikazio bat da.

Fn-n zabaldutako funtzioak ere edukiontzi bereizietan exekutatzen dira, eta horrek programazio-lengoaia asko onartzen ditu, adibidez... Clojure!

Funtzio-argumentuak sarrera estandarrera (STDIN) pasatzen dira, emaitzak irteera estandarrera (STDOUT) idazten dira. Argumentuak edo itzultzeko balioak balio soilak ez badira (adibidez, JSON objektu bat), Fn-ek berak emandako abstrakzio geruza baten bidez bihurtu daitezke Funtzio Garapenerako Kit (FDK) moduan.

Erosotasunerako, txantiloi multzo integratuak eskaintzen dira FaaS hizkuntza ezberdinen eta haien bertsioen zerrenda zabal batean (Go, Java, Python, etab.) zabaltzea errazteko.

FaaS bat sortzea erraza da diagrama hau jarraituz:

  • Funtzioa Fn CLI erabiliz inplementatzea: Fn aplikazioaren konfigurazio fitxategi bat sortzen da hautatutako txantiloian oinarrituta.
  • Gure funtzioa zabaltzen dugu, berriro CLI Fn erabiliz: edukiontziaren irudia biltegi jakin batean jartzen da, eta ondoren zerbitzariari irudi horren existentzia eta kokapenaren berri ematen zaio.

Fn oinarritutako gure zerbitzaririk gabekoa eraikitzea
Fn-i funtzioak emateko printzipioa

Zerbitzaririk gabeko funtzioen tokiko instalazioa eta probak

Has gaitezen Fn instalatzen tokiko makinan. Lehenik eta behin, Docker instalatzen da, Fn-k eskatzen duen moduan. Debian/Ubuntu-n gaudela suposatuz:

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

Edo erabili pakete-kudeatzailea/Docker-en eraikuntza zure sistemaren arabera. Ondoren, zuzenean Fn CLI instalatzera joan zaitezke. Adibidez, kizkurra erabiliz:

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

Homebrew instalatuta daukan OSX-n bazaude, beste bide batetik joan zaitezke:

$ 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

Orain prest gaude hasiera batean gure funtzioa CLI erabiliz zabaltzeko. Sinpletasuna lortzeko, abiarazteko ingurune integratua erabiliko dugu, hala nola Node:

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

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

Direktorio berri bat sortuko da hellonode gure Fn funtzioa oinarrizko konfigurazio fitxategi batzuekin gehiago garatzeko. Sortu berri den direktorioaren barruan, zure aplikazioa sor dezakezu aukeratutako hizkuntzaren edo exekuzio-denboraren estandarrak jarraituz:

# Каталог с 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-k hasierako proiektuaren egitura sortzen du, fitxategi bat sortzen du func.yaml, Fn-rako beharrezko ezarpenak dituena, eta kodearen txantiloia zuk aukeratutako hizkuntzan ezartzen du.

Node exekuzio-denboraren kasuan, honek esan nahi du:

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

Orain azkar probatuko dugu gure funtzioa lokalean dena nola funtzionatzen duen ikusteko.

Lehenik eta behin, Fn zerbitzaria abiaraziko dugu. Esan bezala, Fn zerbitzaria Docker edukiontzi bat da, beraz, abiarazi ondoren, Docker erregistrotik irudia hartuko du.

$ 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

Gure funtzioa exekutatzeko, "zabaldu" behar da. Horrek eskatzen du имя приложения: Fn-n, aplikazio guztiak izen-espazio gisa zehaztu behar dira erlazionatutako funtzioetarako.

Fn CLI-k fitxategia bilatuko du func.yaml funtzioa konfiguratzeko erabiliko den uneko direktorioan. Beraz, lehenik eta behin gure direktoriora joan behar duzu 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

Komandoaren irteeran ikus dezakezun bezala, Docker edukiontziaren irudi berri bat sortzen da gure funtzioa duena. Funtzioa deitzeko prest dago, eta horretarako bi modu ditugu:

  • Fn komandoa erabiliz invoke
  • bidez zuzenean deituz http

deiaren invoke Fn bidez, HTTP bidezko lana emulatzen du probak egiteko, eta hori erosoa da proba azkarrak egiteko:

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

{"message":"Hello World"}

Funtzio bati zuzenean deitzeko, URL osoa ezagutu behar duzu:

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

{"message":"Hello World"}

Fn zerbitzariak bere funtzioak erakusten ditu 8080 atakan eta funtzioaren URLa ereduarekin bat datorrela dirudi t/app/function, baina ez guztiz. HTTP bidez, funtzio bati ez zaio zuzenean deitzen, abiarazle deritzon baten bidez baizik, zeinak, bere izenaren arabera, funtzio-deia "hasi" egiten du. Abiarazleak urtean definitzen dira `func.yml proiektua:

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

Abiarazlearen izena alda dezakegu funtzioaren izenarekin bat etor dadin, honek dena erraztuko du:

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

Ondoren, funtzioa berriro ematen hasiko gara eta abiarazle berri batetik deitzen diogu:

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

{"message":"Hello World"}

Dena dabil! Eskala osoko esperimentuetara pasatzeko eta gure FaaS zerbitzarian argitaratzeko garaia da!

Zerbitzaririk gabeko funtzio zerbitzuak zure azpiegituran instalatzea

Instala dezagun azkar makina birtual bat Exoscale CLI erabiliz. Oraindik konfiguratu ez baduzu, erabil dezakezu gure hasierako gida azkarra. Hau zure produktibitatea are gehiago areagotuko duen tresna polita da. Ez ahaztu Segurtasun Taldean 8080 ataka irekitzeko arau bat konfiguratu behar duzula! Komando hauek makina birtual garbi bat abiaraziko dute, gure funtzioak ostatatzeko prest:

$ 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

Ondoren, ssh makina birtualean sartu eta urruneko Fn zerbitzaria instalatu dezakezu:

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

Ondoren, instalatu Docker eta Fn zerbitzaria lehendik tokiko makinan egin zen moduan, abiarazi zerbitzaria:

$ 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 prest dago funtzioak jasotzeko! Funtzioak urruneko zerbitzari batera transferitzeko, komandoa erabiliko dugu deploy tokiko ordenagailutik bandera kenduta --local.

Horrez gain, Fn-k Fn zerbitzariaren eta Docker erregistroaren kokapena zehaztea eskatzen du. Aukera hauek ingurune-aldagaien bidez ezar daitezke FN_API_URL и FN_REGISTRY hurrenez hurren, baina hedapenerako konfigurazioen sorrera eta kudeaketa erraz kudeatzeko modu erosoagoa ere eskaintzen du.

Fn terminoetan, hedapenerako konfigurazioa deitzen da context. Komando honek testuingurua sortuko du:

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

Eskuragarri dauden testuinguruak honela ikus ditzakezu:

$ fn list contexts

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

Eta aldatu honela sortu berri den testuingurura:

 $ fn use context exoscale

 Now using context: exoscale

Hemendik aurrera, Fn funtzioen bidalketak Docker irudiak deskargatuko ditu hautatutako DockerHub kontua erabiliz (nire kasuan - nfrankel), eta gero urruneko zerbitzariari jakinarazi (adibide honetan - http://185.19.30.175:8080) zure funtzioa duen azken irudiaren kokapenari eta bertsioari buruz.

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

Azkenik:

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

{"message":"Hello World"}

Fn oinarritutako gure zerbitzaririk gabekoa eraikitzea
Funtzioaren bizi-zikloa Fn-en oinarritutako zerbitzaririk gabeko informatikan

Zerbitzaririk gabeko konputazioaren abantailak zure gaitasunean

Zerbitzaririk gabeko konputazioa aplikazio edo mikrozerbitzu konplexuagoekin elkarreragiten duten aplikazio baten zati independenteak azkar inplementatzeko irtenbide erosoa da.

Hau sarritan aukeratutako saltzailean blokeatzeko kostu ezkutuaren ondorioz gertatzen da, eta horrek, erabilera-kasu zehatzaren eta bolumenaren arabera, etorkizunean kostu handiagoak eta malgutasuna murriztea ekar dezake.

Hodei anitzeko eta hodei hibridoen arkitekturak ere sufritzen dute kasu honetan, zerbitzaririk gabeko konputazioa erabili nahiko zenukeen egoera batean erraz aurki dezakezulako, baina politika korporatiboengatik agian ezinezkoa izango da.

Fn erabiltzeko nahiko erraza da eta FaaS interfaze ia bera eskain dezake, gainkostu gutxirekin. Saltzaileen blokeoa kentzen du eta lokalean edo nahi duzun hodeiko soluzio hornitzaile erosoan instalatu daiteke. Programazio-lengoaia aukeratzeko askatasuna ere badago.

Artikulu honek Fn-ren oinarriak soilik biltzen ditu, baina zure exekuzio-denbora sortzea nahiko erraza da, eta arkitektura orokorra zabalagoa izan daiteke Fn karga-orekatzailea erabiliz edo babesteko proxy baten atzean Fn jarriz.

Iturria: www.habr.com

Gehitu iruzkin berria