🥇 მოვლენაზე ორიენტირებული აპლიკაციის მაგალითი, რომელიც დაფუძნებულია ვებჰუკებზე S3 ობიექტების შესანახად Mail.ru Cloud Solutions

Rube Goldberg ყავის აპარატი

მოვლენებზე ორიენტირებული არქიტექტურა ზრდის გამოყენებული რესურსების ხარჯების ეფექტურობას, რადგან ისინი გამოიყენება მხოლოდ იმ მომენტში, როცა საჭიროა. არსებობს მრავალი ვარიანტი, თუ როგორ უნდა განხორციელდეს ეს და არ შექმნათ დამატებითი ღრუბლოვანი ერთეულები, როგორც მუშა აპლიკაციები. და დღეს მე ვისაუბრებ არა FaaS-ზე, არამედ ვებჰუკებზე. მე გაჩვენებთ მოვლენების მართვის მაგალითს ობიექტების შენახვის ვებ-კაუქების გამოყენებით.

რამდენიმე სიტყვა ობიექტების შენახვისა და ვებჰუკების შესახებ. ობიექტების შენახვა საშუალებას გაძლევთ შეინახოთ ნებისმიერი მონაცემი ღრუბელში ობიექტების სახით, ხელმისაწვდომი S3-ით ან სხვა API-ით (დამოკიდებულია განხორციელებაზე) HTTP/HTTPS-ის საშუალებით. Webhooks ზოგადად არის მორგებული HTTP გამოძახება. ისინი, როგორც წესი, გამოწვეულია მოვლენით, როგორიცაა კოდის გადატანა საცავში ან კომენტარის გამოქვეყნება ბლოგზე. როდესაც ხდება მოვლენა, საწყისი საიტი აგზავნის HTTP მოთხოვნას webhook-ისთვის მითითებულ URL-ზე. შედეგად, თქვენ შეგიძლიათ მოაწყოთ მოვლენები ერთ საიტზე, ამოქმედდეს მეორეზე (ვიკი). იმ შემთხვევაში, როდესაც საწყისი საიტი არის ობიექტის საცავი, მოვლენები მოქმედებს როგორც ცვლილებები მის შინაარსში.

მარტივი შემთხვევების მაგალითები, როდესაც ასეთი ავტომატიზაციის გამოყენება შესაძლებელია:

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

მაგალითად, ჩვენ გავაკეთებთ დავალების 1 ვარიანტს, როდესაც Mail.ru Cloud Solutions (MCS) ობიექტების შენახვის თაიგულში ცვლილებები სინქრონიზდება AWS ობიექტების საცავში ვებჰუკების გამოყენებით. რეალურ დატვირთულ შემთხვევაში, ასინქრონული სამუშაო უნდა იყოს უზრუნველყოფილი ვებ-ჰუკების რიგში დარეგისტრირებით, მაგრამ სასწავლო დავალების შესრულებას ამის გარეშე გავაკეთებთ.

სამუშაო სქემა

ურთიერთქმედების პროტოკოლი დეტალურად არის აღწერილი გზამკვლევი S3 webhooks-ზე MCS-ზე. სამუშაო სქემა შეიცავს შემდეგ ელემენტებს:

საგამომცემლო სერვისი, რომელიც არის S3 შენახვის მხარეს და აქვეყნებს HTTP მოთხოვნებს, როდესაც webnhook ამოქმედდება.
Webhook მიმღები სერვერი, რომელიც უსმენს HTTP საგამომცემლო სერვისის თხოვნებს და ასრულებს შესაბამის მოქმედებებს. სერვერი შეიძლება დაიწეროს ნებისმიერ ენაზე; ჩვენს მაგალითში ჩვენ დავწერთ სერვერს Go-ში.

S3 API-ში ვებჰუკების დანერგვის განსაკუთრებული მახასიათებელია ვებჰუკის მიმღები სერვერის რეგისტრაცია გამოქვეყნების სერვისზე. კერძოდ, ვებჰუკის მიმღებმა სერვერმა უნდა დაადასტუროს გამოქვეყნების სერვისის შეტყობინებების ხელმოწერა (ვებჰუკის სხვა დანერგვაში, როგორც წესი, გამოწერის დადასტურება არ არის საჭირო).

შესაბამისად, webhook მიმღებ სერვერს უნდა ჰქონდეს ორი ძირითადი ოპერაცია:

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

ვებჰუკის მიმღები სერვერის ინსტალაცია

ვებჰუკის მიმღები სერვერის გასაშვებად გჭირდებათ Linux სერვერი. ამ სტატიაში, მაგალითად, ვიყენებთ ვირტუალურ მაგალითს, რომელსაც ვაყენებთ MCS-ზე.

მოდით დავაინსტალიროთ საჭირო პროგრამული უზრუნველყოფა და გავუშვათ webhook მიმღების სერვერი.

ubuntu@ubuntu-basic-1-2-10gb:~$ sudo apt-get install git
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following packages were automatically installed and are no longer required:
  bc dns-root-data dnsmasq-base ebtables landscape-common liblxc-common 
liblxc1 libuv1 lxcfs lxd lxd-client python3-attr python3-automat 
python3-click python3-constantly python3-hyperlink
  python3-incremental python3-pam python3-pyasn1-modules 
python3-service-identity python3-twisted python3-twisted-bin 
python3-zope.interface uidmap xdelta3
Use 'sudo apt autoremove' to remove them.
Suggested packages:
  git-daemon-run | git-daemon-sysvinit git-doc git-el git-email git-gui 
gitk gitweb git-cvs git-mediawiki git-svn
The following NEW packages will be installed:
  git
0 upgraded, 1 newly installed, 0 to remove and 46 not upgraded.
Need to get 3915 kB of archives.
After this operation, 32.3 MB of additional disk space will be used.
Get:1 http://MS1.clouds.archive.ubuntu.com/ubuntu bionic-updates/main 
amd64 git amd64 1:2.17.1-1ubuntu0.7 [3915 kB]
Fetched 3915 kB in 1s (5639 kB/s)
Selecting previously unselected package git.
(Reading database ... 53932 files and directories currently installed.)
Preparing to unpack .../git_1%3a2.17.1-1ubuntu0.7_amd64.deb ...
Unpacking git (1:2.17.1-1ubuntu0.7) ...
Setting up git (1:2.17.1-1ubuntu0.7) ...

საქაღალდის კლონირება ვებჰუკის მიმღები სერვერით:

ubuntu@ubuntu-basic-1-2-10gb:~$ git clone
https://github.com/RomanenkoDenys/s3-webhook.git
Cloning into 's3-webhook'...
remote: Enumerating objects: 48, done.
remote: Counting objects: 100% (48/48), done.
remote: Compressing objects: 100% (27/27), done.
remote: Total 114 (delta 20), reused 45 (delta 18), pack-reused 66
Receiving objects: 100% (114/114), 23.77 MiB | 20.25 MiB/s, done.
Resolving deltas: 100% (49/49), done.

მოდით დავიწყოთ სერვერი:

ubuntu@ubuntu-basic-1-2-10gb:~$ cd s3-webhook/
ubuntu@ubuntu-basic-1-2-10gb:~/s3-webhook$ sudo ./s3-webhook -port 80

გამოიწერეთ საგამომცემლო სერვისი

თქვენ შეგიძლიათ დაარეგისტრიროთ თქვენი ვებჰუკის მიმღები სერვერი API-ს ან ვებ ინტერფეისის მეშვეობით. სიმარტივისთვის, ჩვენ დავრეგისტრირდებით ვებ ინტერფეისის საშუალებით:

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

გადადით Webhooks ჩანართზე და დააწკაპუნეთ დამატება:

შეავსეთ ველები:

ID - ვებჰუკის სახელი.

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

URL — ვებჰუკის მიმღები სერვერის მისამართი.

ფილტრის პრეფიქსი/სუფიქსი არის ფილტრი, რომელიც საშუალებას გაძლევთ შექმნათ ვებ-ჰუკები მხოლოდ იმ ობიექტებისთვის, რომელთა სახელები ემთხვევა გარკვეულ წესებს. მაგალითად, იმისათვის, რომ webhook-მა ამოქმედდეს მხოლოდ ფაილები .png გაფართოებით, in ფილტრის სუფიქსი თქვენ უნდა დაწეროთ "png".

ამჟამად, მხოლოდ 80 და 443 პორტებია მხარდაჭერილი ვებჰუკის მიმღებ სერვერზე წვდომისთვის.

მოდით დავაჭიროთ დაამატეთ კაკალი და ჩვენ ვნახავთ შემდეგს:

ჰუკმა დაამატა.

ვებჰუკის მიმღები სერვერი თავის ჟურნალებში აჩვენებს Hook რეგისტრაციის პროცესის მიმდინარეობას:

ubuntu@ubuntu-basic-1-2-10gb:~/s3-webhook$ sudo ./s3-webhook -port 80
2020/06/15 12:01:14 [POST] incoming HTTP request from 
95.163.216.92:42530
2020/06/15 12:01:14 Got timestamp: 2020-06-15T15:01:13+03:00 TopicArn: 
mcs5259999770|myfiles-ash|s3:ObjectCreated:*,s3:ObjectRemoved:* Token: 
E2itMqAMUVVZc51pUhFWSp13DoxezvRxkUh5P7LEuk1dEe9y URL: 
http://89.208.199.220/webhook
2020/06/15 12:01:14 Generate responce signature: 
3754ce36636f80dfd606c5254d64ecb2fd8d555c27962b70b4f759f32c76b66d

რეგისტრაცია დასრულებულია. შემდეგ განყოფილებაში უფრო დეტალურად განვიხილავთ webhook-ის მიმღები სერვერის მუშაობის ალგორითმს.

ვებჰუკის მიმღები სერვერის აღწერა

ჩვენს მაგალითში სერვერი იწერება Go-ში. მოდით შევხედოთ მისი მოქმედების ძირითად პრინციპებს.

package main

// Generate hmac_sha256_hex
func HmacSha256hex(message string, secret string) string {
}

// Generate hmac_sha256
func HmacSha256(message string, secret string) string {
}

// Send subscription confirmation
func SubscriptionConfirmation(w http.ResponseWriter, req *http.Request, body []byte) {
}

// Send subscription confirmation
func GotRecords(w http.ResponseWriter, req *http.Request, body []byte) {
}

// Liveness probe
func Ping(w http.ResponseWriter, req *http.Request) {
    // log request
    log.Printf("[%s] incoming HTTP Ping request from %sn", req.Method, req.RemoteAddr)
    fmt.Fprintf(w, "Pongn")
}

//Webhook
func Webhook(w http.ResponseWriter, req *http.Request) {
}

func main() {

    // get command line args
    bindPort := flag.Int("port", 80, "number between 1-65535")
    bindAddr := flag.String("address", "", "ip address in dot format")
    flag.StringVar(&actionScript, "script", "", "external script to execute")
    flag.Parse()

    http.HandleFunc("/ping", Ping)
    http.HandleFunc("/webhook", Webhook)

log.Fatal(http.ListenAndServe(*bindAddr+":"+strconv.Itoa(*bindPort), nil))
}

განვიხილოთ ძირითადი ფუნქციები:

Ping() - მარშრუტი, რომელიც პასუხობს URL/პინგის საშუალებით, ცოცხალი ზონდის უმარტივესი განხორციელება.
Webhook() - მთავარი მარშრუტი, URL/ვებჰუკის დამმუშავებელი:
- ადასტურებს რეგისტრაციას გამოქვეყნების სერვისზე (გადადით SubscriptionConfirmation ფუნქციაზე),
- ამუშავებს შემომავალ ვებჰუკებს (Gorecords ფუნქცია).
ფუნქციები HmacSha256 და HmacSha256hex არის HMAC-SHA256 და HMAC-SHA256 დაშიფვრის ალგორითმების იმპლემენტაცია, გამომავალი, როგორც თექვსმეტობითი რიცხვების სტრიქონი ხელმოწერის გამოსათვლელად.
main არის მთავარი ფუნქცია, ამუშავებს ბრძანების ხაზის პარამეტრებს და არეგისტრირებს URL-ის დამმუშავებლებს.

სერვერის მიერ მიღებული ბრძანების ხაზის პარამეტრები:

-პორტი არის პორტი, რომელზეც სერვერი მოუსმენს.
-address - IP მისამართი, რომელსაც სერვერი მოუსმენს.
-სკრიპტი არის გარე პროგრამა, რომელიც გამოიძახება ყოველი შემომავალი კაუჭისთვის.

მოდით უფრო დეტალურად განვიხილოთ ზოგიერთი ფუნქცია:

//Webhook
func Webhook(w http.ResponseWriter, req *http.Request) {

    // Read body
    body, err := ioutil.ReadAll(req.Body)
    defer req.Body.Close()
    if err != nil {
        http.Error(w, err.Error(), 500)
        return
    }

    // log request
    log.Printf("[%s] incoming HTTP request from %sn", req.Method, req.RemoteAddr)
    // check if we got subscription confirmation request
    if strings.Contains(string(body), 
""Type":"SubscriptionConfirmation"") {
        SubscriptionConfirmation(w, req, body)
    } else {
        GotRecords(w, req, body)
    }

}

ეს ფუნქცია განსაზღვრავს მოვიდა თუ არა რეგისტრაციის დადასტურების მოთხოვნა ან ვებ-ჰუკი. როგორც ირკვევა დოკუმენტაციათუ რეგისტრაცია დადასტურდა, შემდეგი Json სტრუქტურა მიიღება Post მოთხოვნაში:

POST http://test.com HTTP/1.1
x-amz-sns-messages-type: SubscriptionConfirmation
content-type: application/json

{
    "Timestamp":"2019-12-26T19:29:12+03:00",
    "Type":"SubscriptionConfirmation",
    "Message":"You have chosen to subscribe to the topic $topic. To confirm the subscription you need to response with calculated signature",
    "TopicArn":"mcs2883541269|bucketA|s3:ObjectCreated:Put",
    "SignatureVersion":1,
    "Token":«RPE5UuG94rGgBH6kHXN9FUPugFxj1hs2aUQc99btJp3E49tA»
}

ამ კითხვაზე პასუხის გაცემაა საჭირო:

content-type: application/json

{"signature":«ea3fce4bb15c6de4fec365d36bcebbc34ccddf54616d5ca12e1972f82b6d37af»}

სადაც ხელმოწერა გამოითვლება შემდეგნაირად:

signature = hmac_sha256(url, hmac_sha256(TopicArn, 
hmac_sha256(Timestamp, Token)))

თუ webhook ჩამოვა, Post მოთხოვნის სტრუქტურა ასე გამოიყურება:

POST <url> HTTP/1.1
x-amz-sns-messages-type: SubscriptionConfirmation

{ "Records":
    [
        {
            "s3": {
                "object": {
                    "eTag":"aed563ecafb4bcc5654c597a421547b2",
                    "sequencer":1577453615,
                    "key":"some-file-to-bucket",
                    "size":100
                },
            "configurationId":"1",
            "bucket": {
                "name": "bucketA",
                "ownerIdentity": {
                    "principalId":"mcs2883541269"}
                },
                "s3SchemaVersion":"1.0"
            },
            "eventVersion":"1.0",
            "requestParameters":{
                "sourceIPAddress":"185.6.245.156"
            },
            "userIdentity": {
                "principalId":"2407013e-cbc1-415f-9102-16fb9bd6946b"
            },
            "eventName":"s3:ObjectCreated:Put",
            "awsRegion":"ru-msk",
            "eventSource":"aws:s3",
            "responseElements": {
                "x-amz-request-id":"VGJR5rtJ"
            }
        }
    ]
}

შესაბამისად, მოთხოვნიდან გამომდინარე, თქვენ უნდა გესმოდეთ, როგორ დაამუშავოთ მონაცემები. ინდიკატორად ჩანაწერი ავირჩიე "Type":"SubscriptionConfirmation", რადგან ის იმყოფება გამოწერის დადასტურების მოთხოვნაში და არ არის ვებ-ჰუკში. POST მოთხოვნაში ამ ჩანაწერის არსებობის/არარსებობის საფუძველზე, პროგრამის შემდგომი შესრულება გადადის ან ფუნქციაზე SubscriptionConfirmation, ან ფუნქციაში GotRecords.

ჩვენ არ განვიხილავთ SubscriptionConfirmation ფუნქციას დეტალურად; ის განხორციელებულია ზემოაღნიშნული პრინციპების შესაბამისად. დოკუმენტაცია. ამ ფუნქციის წყაროს კოდის ნახვა შეგიძლიათ აქ პროექტის git საცავი.

GotRecords ფუნქცია აანალიზებს შემომავალ მოთხოვნას და თითოეული ჩანაწერის ობიექტისთვის იძახებს გარე სკრიპტს (რომლის სახელიც გადაეცა -script პარამეტრში) პარამეტრებით:

თაიგულის სახელი
ობიექტის გასაღები
მოქმედება:
- კოპირება - თუ თავდაპირველ მოთხოვნაში EventName = ObjectCreated | PutObject | PutObjectCopy
- წაშლა - თუ თავდაპირველ მოთხოვნაში EventName = ObjectRemoved | DeleteObject

ამრიგად, თუ ჰუკი ჩამოვა Post-ის მოთხოვნით, როგორც აღწერილია ზემოთ, და პარამეტრი -script=script.sh მაშინ სკრიპტი გამოიძახება შემდეგნაირად:

script.sh  bucketA some-file-to-bucket copy

უნდა გვესმოდეს, რომ ეს webhook მიმღები სერვერი არ არის სრული წარმოების გადაწყვეტა, არამედ შესაძლო განხორციელების გამარტივებული მაგალითი.

სამუშაოს მაგალითი

მოდით გავასინქრონოთ ფაილები MCS-ის მთავარი თაიგულიდან AWS-ის სარეზერვო თაიგულამდე. მთავარ თაიგულს ეწოდება myfiles-ash, სარეზერვოს - myfiles-backup (ვედროს კონფიგურაცია AWS-ში სცილდება ამ სტატიის ფარგლებს). შესაბამისად, როდესაც ფაილი მოთავსებულია მთავარ თაიგულში, მისი ასლი უნდა გამოჩნდეს სარეზერვოში, ხოლო როდესაც წაშლილია ძირითადიდან, წაიშლება სარეზერვოში.

ჩვენ ვიმუშავებთ თაიგულებთან awscli უტილიტის გამოყენებით, რომელიც თავსებადია როგორც MCS ღრუბლოვან საცავთან, ასევე AWS ღრუბლოვან საცავთან.

ubuntu@ubuntu-basic-1-2-10gb:~$ sudo apt-get install awscli
Reading package lists... Done
Building dependency tree
Reading state information... Done
After this operation, 34.4 MB of additional disk space will be used.
Unpacking awscli (1.14.44-1ubuntu1) ...
Setting up awscli (1.14.44-1ubuntu1) ...

მოდით დავაკონფიგურიროთ წვდომა S3 MCS API-ზე:

ubuntu@ubuntu-basic-1-2-10gb:~$ aws configure --profile mcs
AWS Access Key ID [None]: hdywEPtuuJTExxxxxxxxxxxxxx
AWS Secret Access Key [None]: hDz3SgxKwXoxxxxxxxxxxxxxxxxxx
Default region name [None]:
Default output format [None]:

მოდით დავაკონფიგურიროთ წვდომა AWS S3 API-ზე:

ubuntu@ubuntu-basic-1-2-10gb:~$ aws configure --profile aws
AWS Access Key ID [None]: AKIAJXXXXXXXXXXXX
AWS Secret Access Key [None]: dfuerphOLQwu0CreP5Z8l5fuXXXXXXXXXXXXXXXX
Default region name [None]:
Default output format [None]:

მოდით შევამოწმოთ წვდომა:

AWS-ზე:

ubuntu@ubuntu-basic-1-2-10gb:~$ aws s3 ls --profile aws
2020-07-06 08:44:11 myfiles-backup

MCS-სთვის, ბრძანების გაშვებისას თქვენ უნდა დაამატოთ —endpoint-url:

ubuntu@ubuntu-basic-1-2-10gb:~$ aws s3 ls --profile mcs --endpoint-url 
https://hb.bizmrg.com
2020-02-04 06:38:05 databasebackups-0cdaaa6402d4424e9676c75a720afa85
2020-05-27 10:08:33 myfiles-ash

წვდომა.

ახლა მოდით დავწეროთ სკრიპტი შემომავალი ჰუკის დასამუშავებლად, დავარქვათ მას s3_backup_mcs_aws.sh

#!/bin/bash
# Require aws cli
# if file added — copy it to backup bucket
# if file removed — remove it from backup bucket
# Variables
ENDPOINT_MCS="https://hb.bizmrg.com"
AWSCLI_MCS=`which aws`" --endpoint-url ${ENDPOINT_MCS} --profile mcs s3"
AWSCLI_AWS=`which aws`" --profile aws s3"
BACKUP_BUCKET="myfiles-backup"

SOURCE_BUCKET=""
SOURCE_FILE=""
ACTION=""

SOURCE="s3://${SOURCE_BUCKET}/${SOURCE_FILE}"
TARGET="s3://${BACKUP_BUCKET}/${SOURCE_FILE}"
TEMP="/tmp/${SOURCE_BUCKET}/${SOURCE_FILE}"

case ${ACTION} in
    "copy")
    ${AWSCLI_MCS} cp "${SOURCE}" "${TEMP}"
    ${AWSCLI_AWS} cp "${TEMP}" "${TARGET}"
    rm ${TEMP}
    ;;

    "delete")
    ${AWSCLI_AWS} rm ${TARGET}
    ;;

    *)
    echo "Usage: #!/bin/bash
# Require aws cli
# if file added — copy it to backup bucket
# if file removed — remove it from backup bucket
# Variables
ENDPOINT_MCS="https://hb.bizmrg.com"
AWSCLI_MCS=`which aws`" --endpoint-url ${ENDPOINT_MCS} --profile mcs s3"
AWSCLI_AWS=`which aws`" --profile aws s3"
BACKUP_BUCKET="myfiles-backup"
SOURCE_BUCKET="${1}"
SOURCE_FILE="${2}"
ACTION="${3}"
SOURCE="s3://${SOURCE_BUCKET}/${SOURCE_FILE}"
TARGET="s3://${BACKUP_BUCKET}/${SOURCE_FILE}"
TEMP="/tmp/${SOURCE_BUCKET}/${SOURCE_FILE}"
case ${ACTION} in
"copy")
${AWSCLI_MCS} cp "${SOURCE}" "${TEMP}"
${AWSCLI_AWS} cp "${TEMP}" "${TARGET}"
rm ${TEMP}
;;
"delete")
${AWSCLI_AWS} rm ${TARGET}
;;
*)
echo "Usage: ${0} sourcebucket sourcefile copy/delete"
exit 1
;;
esac sourcebucket sourcefile copy/delete"
    exit 1
    ;;
esac

მოდით დავიწყოთ სერვერი:

ubuntu@ubuntu-basic-1-2-10gb:~/s3-webhook$ sudo ./s3-webhook -port 80 -
script scripts/s3_backup_mcs_aws.sh

ვნახოთ, როგორ მუშაობს. მეშვეობით MCS ვებ ინტერფეისი დაამატეთ test.txt ფაილი myfiles-ash bucket-ში. კონსოლის ჟურნალები აჩვენებს, რომ მოთხოვნა განხორციელდა webhook სერვერზე:

2020/07/06 09:43:08 [POST] incoming HTTP request from 
95.163.216.92:56612
download: s3://myfiles-ash/test.txt to ../../../tmp/myfiles-ash/test.txt
upload: ../../../tmp/myfiles-ash/test.txt to 
s3://myfiles-backup/test.txt

მოდით შევამოწმოთ myfiles-ს სარეზერვო თაიგულის შინაარსი AWS-ში:

ubuntu@ubuntu-basic-1-2-10gb:~/s3-webhook$ aws s3 --profile aws ls 
myfiles-backup
2020-07-06 09:43:10       1104 test.txt

ახლა, ვებ ინტერფეისის საშუალებით, ჩვენ წავშლით ფაილს myfiles-ash bucket-იდან.

სერვერის ჟურნალები:

2020/07/06 09:44:46 [POST] incoming HTTP request from 
95.163.216.92:58224
delete: s3://myfiles-backup/test.txt

თაიგულის შიგთავსი:

ubuntu@ubuntu-basic-1-2-10gb:~/s3-webhook$ aws s3 --profile aws ls 
myfiles-backup
ubuntu@ubuntu-basic-1-2-10gb:~$

ფაილი წაშლილია, პრობლემა მოგვარებულია.

დასკვნა და დავალება

ამ სტატიაში გამოყენებული ყველა კოდი არის ჩემს საცავში. ასევე არსებობს სკრიპტების მაგალითები და ხელმოწერების დათვლის მაგალითები ვებჰუკების რეგისტრაციისთვის.

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

გისურვებთ წარმატებებს!

მეტი წაკითხვა თემაზე:

წყარო: www.habr.com

მოვლენებზე ორიენტირებული აპლიკაციის მაგალითი, რომელიც დაფუძნებულია ვებჰუკებზე S3 ობიექტების საცავში Mail.ru Cloud Solutions

სამუშაო სქემა

ვებჰუკის მიმღები სერვერის ინსტალაცია

გამოიწერეთ საგამომცემლო სერვისი

ვებჰუკის მიმღები სერვერის აღწერა

სამუშაოს მაგალითი

დასკვნა და დავალება

ახალი კომენტარის დამატება

მოვლენებზე ორიენტირებული აპლიკაციის მაგალითი, რომელიც დაფუძნებულია ვებჰუკებზე S3 ობიექტების საცავში Mail.ru Cloud Solutions

სამუშაო სქემა

ვებჰუკის მიმღები სერვერის ინსტალაცია

გამოიწერეთ საგამომცემლო სერვისი

ვებჰუკის მიმღები სერვერის აღწერა

სამუშაოს მაგალითი

დასკვნა და დავალება

ახალი კომენტარის დამატება პასუხის გასაუქმებლად

ახალი კომენტარის დამატება