როგორ შევქმნათ pluggable Golang პროგრამა და ისარგებლონ AWS Lambda Layers- ით.

გოლანგი - რატომ ღირს თქვენი ყურადღება?

Golang არის ღია კოდის პროგრამირების ენა, რომელიც შეიმუშავა და ახორციელებს Google- მა. იგი ძალიან ფართოდ გამოიყენება თანამედროვე პროგრამებში, განსაკუთრებით ღრუბელში. ისინი ყველაზე დამახასიათებელი ნიშნებია:

  • Golang იწერება სტატიკურად - ის გთავაზობთ ნაკლებ მოქნილობას, მაგრამ იცავს შეცდომებისგან,
  • ეს არ არის ობიექტზე ორიენტირებული. ამასთან, თქვენ შეგიძლიათ შექმნათ სტრუქტურები და ინტერფეისი, რის შედეგადაც წარმოიშობა OOP– დან 4 პრინციპიდან 3: მონაცემთა აბსტრაქცია, კაფსულაცია და პოლიმორფიზმი. მხოლოდ მემკვიდრეობა აკლია
  • გოროტინები! - სინათლის ძაფების საუკეთესო განხორციელება, რომელიც მე ოდესმე გამომიყენებია. Go ოპერატორის საშუალებით თქვენ შეგიძლიათ მარტივად შექმნათ ახალი თემა და დაუკავშირდეთ კომუნიკაციებს სხვადასხვა goroutines- ს შორის.
  • იგი შედგენილია ერთ ორობით ფაილში ყველა დამოკიდებულებით - აღარ არის კონფლიქტის პაკეტი!

პირადად მე გოლანგი მიმაჩნია უდიდეს ენად, რომელსაც ყოველდღე ვიყენებ. ამასთან, ეს სტატია არ ეხება თქვენი პირველი ფუნქციის შექმნას ან "Hello World" - ის დაბეჭდვას. მე გაჩვენებთ ცოტა უფრო დახვეწილ ნივთებს. თუ თქვენ ხართ დამწყები და გსურთ გაიგოთ მეტი გოლანგის შესახებ, ეწვიეთ მთავარ გვერდს.

AWS Lambda & Golang

AWS Lambda არის ერთ – ერთი ყველაზე პოპულარული სერვერული გამოთვლითი სერვისი საზოგადოებრივ ღრუბელში, რომელიც გამოქვეყნდა Amazon Web Services– ის მიერ 2014 წლის ნოემბერში. თქვენი კოდის გაშვება შეგიძლიათ DynamoDB, SNS ან HTTP ტრიგერების მსგავსი მოვლენების საპასუხოდ, სერვერების დაყენებისა და მართვის გარეშე! იცით რა არის მართლაც კარგი? ის გოლანგის ტერმინს მხარს უჭერს 2018 წლის იანვრიდან. AWS Lambda- სთან მუშაობა ძალიან მარტივია - უბრალოდ ატვირთეთ კომპრესირებული პაკეტი თქვენს კოდთან და ყველა დამოკიდებულებასთან ერთად (ერთი ორობითი თუ იყენებთ Golang- ს).

სწრაფი ნაბიჯით, 4 წლის შემდეგ, 2018 წელი: გამოიგონეთ AWS Lambda Layers, რომელიც საშუალებას გაძლევთ შეინახოთ და მართოთ სხვადასხვა ფუნქციისთვის გაზიარებული მონაცემები ერთ ან თუნდაც მრავალ AWS ანგარიშში! მაგალითად, თუ იყენებთ Python- ს, შეგიძლიათ განათავსოთ ყველა დამოკიდებულება დამატებით ფენაში, რომლის გამოყენება შეიძლება შემდგომ სხვა ლამბდებმა. აღარ არის საჭირო თითოეულ დალაგებულ პაკეტში სხვადასხვა დამოკიდებულების დამატება! გოლანგის სამყაროში სხვაგვარი სიტუაციაა, რადგან AWS Lambda მოითხოვს შედგენილი ბინარების ატვირთვას. როგორ შეგვიძლია ისარგებლოს AWS Lambda Layers? პასუხი მარტივია - ააშენეთ მოდულური პროგრამა Golang დანამატებით!

Golang plugins - მოდულური აპლიკაციის შესაქმნელად

Golang Plugins არის ფუნქცია, გამოშვებული Go1.8, რომელიც საშუალებას გაძლევთ დინამიურად ჩატვირთოთ გაზიარებული ბიბლიოთეკები (.so ფაილი). თქვენ გაქვთ შესაძლებლობა თქვენი კოდის ნაწილი გაატაროთ ცალკე ბიბლიოთეკაში ან გამოიყენოთ დანამატი, რომელიც სხვის მიერ შეიქმნა და შეადგინა. ამასთან, სასიხარულოა, რომ არსებობს გარკვეული შეზღუდვები:

  • თქვენი დანამატი უნდა იყოს ერთი მთავარი მოდული,
  • თქვენ შეგიძლიათ მხოლოდ ჩატვირთოთ ფუნქციები და ცვლადები, რომლებიც ექსპორტირდება როგორც ELF სიმბოლო.
  • სტატიკური აკრეფის გამო, თქვენ უნდა გადააკეთოთ ყველა დატვირთული სიმბოლო სწორ ტიპზე. უარეს შემთხვევაში, თქვენს კოდში უნდა განსაზღვროთ სწორი ინტერფეისი,
  • ის მუშაობს მხოლოდ Linux- სა და MacOS- ზე. პირადად მე ამას ვერ ვხედავ როგორც მინუს :)

შექმენით და გამოსცადეთ თქვენი პირველი დანამატი

მოდით შევქმნათ ჩვენი პირველი მოდული. მაგალითად, ჩვენ შევქმნით სიმების დაშიფვრის მარტივ მოდულს. დავუბრუნდეთ საფუძვლებს და განვახორციელოთ ორი მარტივი დაშიფვრის ალგორითმი - Ceasar და Verman.

  • კეისრის კოდი არის ჯულიუს ჩეასის მიერ პირველად გამოყენებული ალგორითმი. იგი ტექსტში ატარებს თითოეულ ასოს ადგილების მითითებულ რაოდენობას. მაგალითად, თუ გსურთ სიტყვა golang დაშიფროთ გასაღებით 4, მიიღებთ ktpek. გაშიფვრა ისევე მუშაობს. თქვენ მხოლოდ ასოების საპირისპირო მიმართულებით გადატანა გჭირდებათ.
  • ვერმანის კოდი მსგავსია Ceaser შიფრისა, რომელიც დაფუძნებულია იმავე ცვალებად იდეაზე. განსხვავება იმაშია, რომ თქვენ თითოეულ ასოზე გადაადგილდებით პოზიციების სხვადასხვა რაოდენობა. ტექსტის გასაშიფრად გჭირდებათ გასაღები პოზიციებით, სადაც ტექსტი დაშიფრულია. მაგალითად, თუ გსურთ სიტყვის golang კოდირებით დაშიფვრა [-1, 4, 7, 20, 4, -2], თქვენ მიიღებთ მომავალს.

ამ მაგალითის სრული დანერგვა შეგიძლიათ იხილოთ აქ.

მოდულის დანერგვა

შემდეგი ფრაგმენტი შეიცავს ზემოთ ხსენებული ორი ალგორითმის განხორციელებას. თითოეულისთვის, ჩვენ ვახორციელებთ ჩვენი ტექსტის დაშიფვრისა და გაშიფვრის ორ მეთოდს:

როგორც ხედავთ, ჩვენ ექსპორტირებული გვაქვს 3 განსხვავებული სიმბოლო (Golang ექსპორტს ახორციელებს მხოლოდ ამ იდენტიფიკატორებისგან, რომლებიც იწყება ასოთი):

  • EncryptCeasar - func (int, string) სტრიქონი, რომელიც აშიფრავს ტექსტს Ceasar ალგორითმით.
  • DecryptCeaser - func (int, string) სტრიქონი, რომელიც ტექსტის დეკოდირებას ახდენს Caeser- ის ალგორითმის გამოყენებით,
  • VermanCipher - ტიპის vermanCipher ცვლადი, რომელიც ახორციელებს 2 მეთოდს: დაშიფვრა: func (string) string და Decrypt: func () (* string, შეცდომა)

ამ მოდულის შესადგენად უნდა გაუშვათ შემდეგი ბრძანება:

go build -buildmode = plugin -o plugin / cipher.so plugin / cipher.go

ამ ეტაპზე არაფერია განსაკუთრებული - შეიქმნა მხოლოდ რამდენიმე მარტივი ფუნქცია და მოდული შეადგინეს როგორც მოდული, დაამატეთ -buildmode = მოდული არგუმენტი.

ჩატვირთეთ და შეამოწმეთ მოდული

სიამოვნება იწყება მაშინ, როდესაც გვინდა შედგენილი დანამატის გამოყენება ჩვენს აპში. მოდით შევქმნათ მარტივი მაგალითი:

პირველ რიგში უნდა მოაწყოთ Golang მოდულის პაკეტი. იგი შეიცავს მხოლოდ ორ ფუნქციას - პირველი არის გაზიარებული ბიბლიოთეკის ჩატვირთვა და მეორე - ექსპორტირებული სიმბოლოს პოვნა. თქვენი ბიბლიოთეკის დასატვირთად უნდა გამოიყენოთ ღია ფუნქცია, რისთვისაც მითითებული უნდა იყოს თქვენი გაზიარებული დანამატის გზა და ტიპის დანამატის დასაბრუნებელი ცვლადი. თუ ბიბლიოთეკის ჩატვირთვა შეუძლებელია (მაგ. არასწორი გზა ან დაზიანებული ფაილი), ეს ფუნქცია უბრუნებს შეცდომას, რომლის მოგვარებაც აუცილებელია.

შემდეგი ნაბიჯი არის თითოეული ექსპორტირებული სიმბოლოს ჩატვირთვა ძიების მეთოდის გამოყენებით. მცირე მინუსი ის არის, რომ თქვენ უნდა გადმოწეროთ თითოეული ექსპორტირებული ფუნქცია ცალკე. ამასთან, შეგიძლიათ მრავალი ფუნქციის შერწყმა ისე, როგორც ეს გააკეთეთ VermanCipher სიმბოლოსთვის. ყველა სიმბოლოს ჩატვირთვის შემდეგ, რომლის გამოყენებაც გსურთ, საჭიროა მათი სწორი ტიპით გადაკეთება. გოლანგი არის სტატიკურად აკრეფილი ენა, ამიტომ ამ სიმბოლოების გამოყენების სხვა გზა არ არსებობს. დაიმახსოვრე, თუ ექსპორტიორი ხარ ცვლადში, რომელიც ახორციელებს ზოგიერთ მეთოდს, საჭიროა მისი ინტერფეისის სწორი ტიპზე მიტანა (ამის გასამარტივებლად მე უნდა განვსაზღვრო encryptionEngine ინტერფეისი). \ Newline \ newline

გამოიყენეთ შემდეგი ბრძანება აპის შესადგენად და გასაშვებად:

წადი ააშენე app.go ./app

გამომავალში დაინახეთ დაშიფრული და გაშიფრული ტექსტი, რომ ალგორითმი სწორად მუშაობს.

გამოიყენეთ მოდული AWS Lambda- ში

იმისათვის, რომ გამოვიყენოთ ჩვენი დანამატი AWS Lambda– ში, საჭიროა გარკვეული ცვლილებები შევიტანოთ ჩვენს პროგრამაში:

  • AWS Lambda აყენებს შრეებს Lambda კონტეინერში / opt დირექტორიაში, ამიტომ ჩვენ უნდა ავტვირთოთ ჩვენი დანამატი ამ დირექტორიიდან.
  • ჩვენ უნდა შევქმნათ დამმუშავებლის ფუნქცია, რომელსაც გამოიყენებს Lambda ძრავა ჩვენი სატესტო ღონისძიების დასამუშავებლად.

შემდეგი ფრაგმენტი შეიცავს ჩვენს პროგრამას, რომელიც ადაპტირებული იქნა Lambda– ს გამოყენებისთვის:

როგორც ხედავთ, განხორციელება ძალიან ჰგავს წინას. ჩვენ უბრალოდ შევცვალეთ დირექტორია, საიდანაც ჩავტვირთეთ ჩვენი დანამატი და დავამატეთ ფუნქციის პასუხი მნიშვნელობების დაბეჭდვის ნაცვლად. გოლანგში ლამბდების წერის შესახებ დამატებითი ინფორმაციისთვის იხილეთ AWS დოკუმენტაცია.

AWS ლამბდას განთავსება

AWS Lambda ფუნქციების და ფენების განლაგების ორი გზა არსებობს. თქვენ შეგიძლიათ შექმნათ და ატვირთოთ კომპრესირებული პაკეტი ხელით ან გამოიყენოთ მოწინავე ჩარჩო, რაც გაცილებით მარტივად და სწრაფად გახდის მას. ჩემი უმეტეს პროექტებისთვის ვიყენებ სერვერულ ჩარჩოს. ამიტომ მე უკვე მოვამზადე მარტივი კონფიგურაციის ფაილი serverless.yml ამ ინსტრუმენტის საშუალებით:

მომსახურება: cipherService frameworkVersion: "> = 1.28.0 <2.0.0" მომწოდებელი: სახელი: aws Runtime: go1.x
Layers: cipherLayer: Path: bin / plugin თავსებადი ხანგრძლივობა: - go1.x
ფუნქციები: ძრავა: დამმუშავებელი: bin / cipherEngine შეფუთვა: გამორიცხვა: - ./** ჩართვა: - ./bin/cipherEngine შრეები: - {Ref: CipherLayerLambdaLayer}

შრის არეალში ჩვენ განვსაზღვრეთ ერთი ფენა დანამატისკენ მიმავალი ბილიკით, რომელიც უკვე შეიქმნა - ეს მოცემულია Lambda ფუნქციასთან ერთად. თქვენ შეგიძლიათ განსაზღვროთ 5-მდე სხვადასხვა დონე, რომელთა რიგი ნამდვილად მნიშვნელოვანია. ისინი დამონტაჟებულია იმავე / ოპ დირექტორიაში, ამიტომ უფრო მეტი რაოდენობის ფენებს შეუძლიათ ფაილების გადაწერა ადრე დამონტაჟებული ფენებიდან. თითოეული დონისთვის უნდა მიუთითოთ მინიმუმ 2 პარამეტრი: დირექტორიის გეზი დონის წყაროსთან (თქვენს შემთხვევაში გზავნილის დანამატის ორობითი ფაილიდან) და თავსებადი სამუშაოების ჩამონათვალი.

შემდეგი ფუნქციების განყოფილება არის ადგილი, სადაც განსაზღვრავთ განსახორციელებელი ფუნქციების ჩამონათვალს. თითოეული ფუნქციისთვის მინიმუმ უნდა მიუთითოთ შედგენილი აპლიკაციის გზა. გარდა ამისა, ჩვენ უნდა განვსაზღვროთ ფენის პარამეტრი ზემოთ მითითებული ფენის მითითებით. ეს ავტომატურად დაერთვება ფენას Lambda ფუნქციას განლაგების დროს. სასაცილო ის არის, რომ თუ გსურთ ამ რესურსის მითითება, თქვენ უნდა გადააკეთოთ თქვენი Lambda ფენის სახელი TitleCased და დაამატოთ LambdaLayer სუფიქსი. როგორც ჩანს, სერვერულმა გუნდმა ეს გამოიყენა სხვადასხვა სახის რესურსებთან დაკავშირებული კონფლიქტის მოსაგვარებლად.

როგორც კი ჩვენი კონფიგურაციის ფაილი serverless.yml მზად იქნება, ბოლო რაც თქვენ უნდა გააკეთოთ, არის ჩვენი აპის შედგენა, მიერთება და განლაგება. ამისათვის შეგვიძლია გამოვიყენოთ მარტივი Makefile:

.PHONY: აშენების BuildPlugin განლაგებას სუფთად
build: dep safe -v env GOOS = Linux go build -ldflags = "-s -w" -o bin / cipherEngine cipherEngine / main.go
buildPlugin: env GOOS = Linux go build -ldflags = "- s -w" -buildmode = Plugin -o bin / plugin / cipher.so ../plugin/cipher.go
სუფთა: rm -rf ./bin ./vendor Gopkg.lock
განლაგება: სუფთა buildPlugin build sls განლაგება - verbose

თქვენი ფუნქციის შექმნა და განლაგება შეგიძლიათ შემდეგი ბრძანების შესრულებით:

უზრუნველყოფა

სცადეთ AWS Lambda

როგორც უკვე აღვნიშნეთ, AWS Lambda Code მუშაობს ამ ღონისძიების საპასუხოდ. ამასთან, ჩვენ არ მივაყენეთ კონფიგურაცია რაიმე მოვლენის ტრიგერებს, ასე რომ მათ ვერ დაურეკავთ ჩვენი დახმარების გარეშე. ხელით უნდა გავაკეთოთ Serverless Framework ან awscli ინსტრუმენტით:

sls ზარები -f ფუნქცია-სახელი aws lambda invoke - ფუნქცია-სახელი ფუნქცია-სახელი გამომავალი ფაილი

პასუხში, თქვენ უნდა დაინახოთ იგივე გამომავალი, რაც ადრე, რაც ადასტურებს, რომ ჩვენი lambda ფუნქცია სწორად მუშაობს და მოდული იტვირთება დამატებითი ფენიდან. ახლა თქვენ შეგიძლიათ შექმნათ სხვა ფუნქციები, რომლებიც იყენებენ იმავე ფენას ან თუნდაც გააზიარეთ იგი სხვა AWS ანგარიშებთან.

Შემაჯამებელი

ეს იყო დიდი სიამოვნება Golang მოდულების გამოყენებით და იმის ტესტირება, თუ როგორ შეიძლებოდა მათი ინტეგრაცია ახლად გამოცემულ AWS Lambda Layers- თან. მოდულების ბიბლიოთეკა მართლაც შესანიშნავია, მაგრამ მისი გამოყენება მხოლოდ გარკვეულ სცენარებშია შესაძლებელი მისი შეზღუდვებისა და Golang– ის სპეციფიკაციების გამო. მე ვფიქრობ, რომ დეველოპერების უმეტესობისთვის, რომლებიც მუშაობენ სტანდარტულ პროექტებზე, დანამატები არ არის საჭირო და არც შესაძლებელია. მხოლოდ ორ მიზეზზე ვფიქრობ:

  • რთული ალგორითმების განხორციელება, რომელთა გამოყენება შეიძლება სხვა პროგრამებმაც, მაგ. ვიდეო კოდირების ან დაშიფვრის ალგორითმები.
  • გაუზიარეთ თქვენი ალგორითმი სხვებს კოდის გამოქვეყნების გარეშე.