🥇สร้างเซิร์ฟเวอร์แบบไร้เซิร์ฟเวอร์ของเราเองโดยใช้ Fn

การประมวลผลแบบไร้เซิร์ฟเวอร์ เป็นหนึ่งในเทรนด์ที่โดดเด่นที่สุดในคลาวด์คอมพิวติ้ง หลักการทำงานขั้นพื้นฐานคือโครงสร้างพื้นฐานไม่ใช่เรื่องของ DevOps แต่เป็นของผู้ให้บริการ การปรับขนาดทรัพยากรจะปรับตามโหลดโดยอัตโนมัติและมีอัตราการเปลี่ยนแปลงสูง

คุณสมบัติทั่วไปอีกประการหนึ่งคือแนวโน้มที่จะย่อเล็กสุดและโฟกัสโค้ด ซึ่งเป็นเหตุผลว่าทำไมบางครั้งการประมวลผลแบบไร้เซิร์ฟเวอร์จึงถูกเรียกว่าฟังก์ชันเป็นบริการ (FaaS)

ในอดีต ผู้ให้บริการระบบคลาวด์รายแรกที่เสนอ FaaS กับ AWS Lambda คือ Amazon จึงเป็นที่มาของชื่อ ผู้ให้บริการคลาวด์รายอื่นก็มีผู้ให้บริการที่คล้ายกัน:

ฟังก์ชั่นคลาวด์จาก Google
ฟังก์ชัน Azure จาก Microsoft

บริษัทเหล่านี้ทั้งหมดให้บริการการประมวลผลแบบไร้เซิร์ฟเวอร์ ปรับขนาดอัตโนมัติ และจ่ายเฉพาะส่วนที่คุณใช้จริงเท่านั้น แต่บริษัทเหล่านี้จะล็อคลูกค้าให้เข้าถึงผลิตภัณฑ์ที่เป็นกรรมสิทธิ์ของตน อย่างไรก็ตาม มีทางเลือกโอเพ่นซอร์สฟรีสำหรับการประมวลผลแบบไร้เซิร์ฟเวอร์ เป็นที่น่าสังเกตว่า:

แพลตฟอร์ม อาปาเช่ OpenWhiskที่ถูกพัฒนาในตู้ฟักโดยไอบีเอ็ม
ฟังก์ชั่นสปริงคลาวด์ซึ่งเป็นส่วนหนึ่งของระบบนิเวศ Spring Framework ที่ค่อนข้างสมบูรณ์ ซึ่งสามารถใช้เป็นส่วนหน้าสำหรับ AWS Lambda, Azure Functions และ OpenWhisk ได้ด้วย
โครงการเอฟเอ็นซึ่งได้รับการสนับสนุนโดยออราเคิล

ทั้งหมดเป็นอิสระจากคลาวด์โดยสิ้นเชิง กล่าวคือ สามารถติดตั้งได้บนคลาวด์ใดก็ได้ รวมถึงของคุณเอง สาธารณะหรือส่วนตัว และแน่นอนใน Exoscale

โครงการ Fn ทำงานอย่างไร

Fn มีพื้นฐานมาจาก Docker โดยสมบูรณ์ ประกอบด้วยองค์ประกอบหลัก XNUMX ส่วน:

โปรแกรม CLI ออกแบบมาเพื่อจัดการโครงสร้างพื้นฐาน Fn ทุกด้าน และโต้ตอบกับเซิร์ฟเวอร์ Fn
เซิร์ฟเวอร์ Fn นั้นเป็นแอปพลิเคชันทั่วไปที่บรรจุอยู่ในคอนเทนเนอร์นักเทียบท่า

ฟังก์ชันที่ใช้งานใน Fn จะถูกดำเนินการในคอนเทนเนอร์ที่แยกจากกันด้วย ซึ่งช่วยให้คุณรองรับภาษาการเขียนโปรแกรมได้มากมาย เช่น... Clojure!

อาร์กิวเมนต์ของฟังก์ชันจะถูกส่งผ่านไปยังอินพุตมาตรฐาน (STDIN) ผลลัพธ์จะถูกเขียนไปยังเอาต์พุตมาตรฐาน (STDOUT) หากอาร์กิวเมนต์หรือค่าที่ส่งคืนไม่ใช่ค่าธรรมดา (เช่น อ็อบเจ็กต์ JSON) ก็สามารถแปลงได้โดยใช้เลเยอร์นามธรรมที่ Fn เตรียมไว้ให้ในรูปแบบของ Function Development Kit (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

หรือใช้ตัวจัดการแพ็คเกจ/นักเทียบท่าบิลด์ตามระบบของคุณ จากนั้นคุณก็สามารถดำเนินการติดตั้ง 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 เพื่อความง่าย เราจะใช้สภาพแวดล้อมการเปิดตัวในตัว เช่น โหนด:

$ 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 และตั้งค่าเทมเพลตสำหรับโค้ดในภาษาที่คุณเลือก

ในกรณีของรันไทม์ของโหนด หมายความว่า:

$ 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 ไว้ด้านหลังพร็อกซีเพื่อป้องกัน

ที่มา: will.com

การสร้างเซิร์ฟเวอร์แบบไร้เซิร์ฟเวอร์ของเราเองโดยใช้ Fn

โครงการ Fn ทำงานอย่างไร

การติดตั้งและการทดสอบฟังก์ชันแบบไร้เซิร์ฟเวอร์ในเครื่อง

การติดตั้งบริการฟังก์ชันไร้เซิร์ฟเวอร์บนโครงสร้างพื้นฐานของคุณเอง

ข้อดีของการประมวลผลแบบไร้เซิร์ฟเวอร์ตามความสามารถของคุณเอง

เพิ่มความคิดเห็น ยกเลิกการตอบ