🥇 Իրադարձությունների վրա հիմնված հավելվածի օրինակ, որը հիմնված է վեբկեռիկների վրա S3 օբյեկտների պահեստում Mail.ru Cloud Solutions

Rube Goldberg սուրճի մեքենա

Իրադարձությունների վրա հիմնված ճարտարապետությունը մեծացնում է օգտագործվող ռեսուրսների ծախսարդյունավետությունը, քանի որ դրանք օգտագործվում են միայն այն պահին, երբ դրանք անհրաժեշտ են: Կան բազմաթիվ տարբերակներ, թե ինչպես դա իրականացնել և չստեղծել լրացուցիչ ամպային սուբյեկտներ որպես աշխատող հավելվածներ: Իսկ այսօր ես կխոսեմ ոչ թե FaaS-ի, այլ webhook-ների մասին։ Ես ցույց կտամ իրադարձությունների կառավարման ուսուցողական օրինակ՝ օգտագործելով օբյեկտների պահպանման վեբկեռիկներ:

Մի քանի խոսք օբյեկտների պահպանման և վեբ-կեռիկների մասին: Օբյեկտների պահպանումը թույլ է տալիս ցանկացած տվյալներ պահել ամպի մեջ օբյեկտների տեսքով, որոնք հասանելի են S3-ի կամ այլ API-ի միջոցով (կախված իրականացումից) HTTP/HTTPS-ի միջոցով: Webhooks-ը, ընդհանուր առմամբ, սովորական HTTP զանգեր են: Դրանք սովորաբար հրահրվում են իրադարձության հետևանքով, օրինակ՝ կոդի մուտքագրումը պահեստ կամ մեկնաբանություն, որը տեղադրվում է բլոգում: Երբ իրադարձություն է տեղի ունենում, սկզբնաղբյուր կայքը HTTP հարցում է ուղարկում վեբ-կապիկի համար նշված URL-ին: Արդյունքում, դուք կարող եք իրադարձություններ կատարել մի կայքում, որոնք գործարկում են մյուսի վրա (Վիքիփեդիա, ազատ հանրագիտարան) Այն դեպքում, երբ սկզբնաղբյուր կայքը օբյեկտի պահեստ է, իրադարձությունները գործում են որպես դրա բովանդակության փոփոխություններ:

Պարզ դեպքերի օրինակներ, երբ նման ավտոմատացումը կարող է օգտագործվել.

Բոլոր օբյեկտների պատճենների ստեղծում մեկ այլ ամպային պահեստում: Պատճենները պետք է ստեղծվեն անմիջապես, երբ ֆայլերը ավելացվեն կամ փոխվեն:
Գրաֆիկական ֆայլերի մի շարք մանրապատկերների ավտոմատ ստեղծում, լուսանկարներին ջրանիշերի ավելացում և պատկերների այլ փոփոխություններ:
Ծանուցում նոր փաստաթղթերի ժամանման մասին (օրինակ՝ բաշխված հաշվապահական ծառայությունը հաշվետվություններ է վերբեռնում ամպի մեջ, իսկ ֆինանսական մոնիտորինգը ստանում է ծանուցումներ նոր հաշվետվությունների մասին, ստուգում և վերլուծում դրանք):
Մի փոքր ավելի բարդ դեպքերը ներառում են, օրինակ, հարցում առաջացնելը Kubernetes-ին, որը ստեղծում է պատիճ՝ անհրաժեշտ բեռնարկղերով, փոխանցում է առաջադրանքի պարամետրերը և մշակումից հետո փլուզում է կոնտեյները։

Որպես օրինակ, մենք կկատարենք առաջադրանքի 1 տարբերակ, երբ Mail.ru Cloud Solutions (MCS) օբյեկտների պահեստավորման դույլի փոփոխությունները համաժամեցվեն AWS օբյեկտների պահեստում՝ օգտագործելով վեբկեռիկներ: Իրական ծանրաբեռնված դեպքում ասինխրոն աշխատանք պետք է տրամադրվի՝ հերթում գրանցելով վեբ-կեռիկներ, բայց ուսուցման առաջադրանքի համար մենք իրականացումը կկատարենք առանց դրա:

Աշխատանքային սխեման

Փոխազդեցության արձանագրությունը մանրամասն նկարագրված է S3 վեբկեռիկների ուղեցույց MCS-ում. Աշխատանքային սխեման պարունակում է հետևյալ տարրերը.

Հրատարակչական ծառայություն, որը գտնվում է S3 պահեստավորման կողմում և հրապարակում է HTTP հարցումներ, երբ գործարկվում է webnhook-ը:
Webhook ստացող սերվեր, որը լսում է HTTP հրատարակչական ծառայության հարցումները և կատարում համապատասխան գործողություններ։ Սերվերը կարող է գրվել ցանկացած լեզվով, մեր օրինակում մենք սերվերը կգրենք Go-ում:

S3 API-ում վեբ-կեռիկների ներդրման առանձնահատուկ առանձնահատկությունը հրապարակման ծառայության վրա վեբ-կեռիկներ ստացող սերվերի գրանցումն է: Մասնավորապես, webhook ստացող սերվերը պետք է հաստատի հրատարակչական ծառայության հաղորդագրությունների բաժանորդագրությունը (webhook-ի այլ իրականացումներում բաժանորդագրության հաստատումը սովորաբար չի պահանջվում):

Համապատասխանաբար, webhook ստացող սերվերը պետք է աջակցի երկու հիմնական գործողություն.

պատասխանել հրատարակչական ծառայության խնդրանքին՝ գրանցումը հաստատելու համար,
մշակել մուտքային իրադարձությունները.

Webhook ստացող սերվերի տեղադրում

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

Կլոնավորեք թղթապանակը webhook ստացող սերվերով.

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

Բաժանորդագրվեք հրատարակչական ծառայությանը

Դուք կարող եք գրանցել ձեր webhook ընդունող սերվերը API-ի կամ վեբ ինտերֆեյսի միջոցով: Պարզության համար մենք գրանցվելու ենք վեբ ինտերֆեյսի միջոցով.

Անցնենք դույլերի բաժին կառավարման սենյակում:
Գնացեք այն դույլը, որի համար մենք կկարգավորենք վեբ-կեռիկներ և կտտացրեք հանդերձում.

Գնացեք Webhooks ներդիր և կտտացրեք Ավելացնել.

Լրացրեք դաշտերը.

ID - վեբ-կապիկի անվանումը:

Իրադարձություն - որ իրադարձությունները փոխանցել: Մենք սահմանել ենք բոլոր իրադարձությունների փոխանցումը, որոնք տեղի են ունենում ֆայլերի հետ աշխատելիս (ավելացնելով և ջնջելով):

URL - վեբ-կեռիկի ստացող սերվերի հասցե:

Ֆիլտրի նախածանցը / վերջածանցը ֆիլտր է, որը թույլ է տալիս ստեղծել վեբ-կեռիկներ միայն այն օբյեկտների համար, որոնց անունները համապատասխանում են որոշակի կանոններին: Օրինակ, որպեսզի webhook-ը գործարկի միայն .png ընդլայնմամբ ֆայլերը, in Զտիչի վերջածանց պետք է գրել «png»:

Ներկայումս միայն 80-րդ և 443-րդ նավահանգիստներն են աջակցվում վեբ-կեռիկներ ստացող սերվեր մուտք գործելու համար:

Եկեք սեղմենք Ավելացնել կարթ և մենք կտեսնենք հետևյալը.

Հուկը ավելացրեց.

Webhook ստացող սերվերն իր տեղեկամատյաններում ցույց է տալիս կեռիկի գրանցման գործընթացի առաջընթացը.

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 ընդունիչ սերվերի աշխատանքի ալգորիթմին:

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/ping-ի միջոցով, կենդանի զոնդի ամենապարզ իրականացումը:
Webhook() - հիմնական երթուղի, URL/webhook handler:
- հաստատում է գրանցումը հրատարակչական ծառայության վրա (անցեք SubscriptionConfirmation ֆունկցիային),
- մշակում է մուտքային վեբ-կեռիկներ (Gorecords ֆունկցիա):
HmacSha256 և HmacSha256hex գործառույթները HMAC-SHA256 և HMAC-SHA256 գաղտնագրման ալգորիթմների իրականացումն են, որոնք թողարկվում են որպես տասնվեցական թվերի շարան՝ ստորագրությունը հաշվարկելու համար:
main-ը հիմնական գործառույթն է, մշակում է հրամանի տողի պարամետրերը և գրանցում URL մշակողներին:

Սերվերի կողմից ընդունված հրամանի տողի պարամետրերը.

-պորտը այն նավահանգիստն է, որի վրա սերվերը կլսի:
-address - IP հասցե, որը սերվերը կլսի:
-script-ը արտաքին ծրագիր է, որը կանչվում է յուրաքանչյուր մուտքային կեռիկի համար:

Եկեք ավելի սերտ նայենք որոշ գործառույթներին.

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

Եթե վեբ-կապը գալիս է, ապա 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 ֆունկցիան վերլուծում է մուտքային հարցումը և յուրաքանչյուր Record օբյեկտի համար կանչում է արտաքին սկրիպտ (որի անունը փոխանցվել է -script պարամետրում) հետևյալ պարամետրերով.

դույլի անվանումը
օբյեկտի բանալին
գործողություն:
- պատճեն - եթե սկզբնական հարցումում EventName = ObjectCreated | PutObject | PutObjectCopy
- ջնջել - եթե սկզբնական հարցումում EventName = ObjectRemoved | Ջնջել օբյեկտը

Այսպիսով, եթե կեռիկը գալիս է 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 դույլին: Վահանակի տեղեկամատյանները ցույց են տալիս, որ հարցում է արվել 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-backup bucket-ի բովանդակությունը 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 դույլից:

Սերվերի տեղեկամատյաններ.

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) և այնտեղից վերլուծեք դրանք և մշակեք դրանք: աշխատողների դիմումներով: Հակառակ դեպքում, երբ վեբ-կեռիկները զանգվածաբար ժամանում են, դուք կարող եք հանդիպել սերվերի ռեսուրսների բացակայությանը՝ առաջադրանքները կատարելու համար: Հերթերի առկայությունը թույլ է տալիս բաշխել սերվերը և աշխատողները, ինչպես նաև խնդիրներ լուծել անհաջողությունների դեպքում կրկնվող առաջադրանքների հետ: Ցանկալի է նաև փոխել անտառահատումները ավելի մանրամասն և ստանդարտացվածի:

Հաջողություն!

Թեմայի վերաբերյալ ավելի շատ ընթերցումներ.

Source: www.habr.com

Իրադարձությունների վրա հիմնված հավելվածի օրինակ, որը հիմնված է վեբկեռիկների վրա S3 օբյեկտների պահեստում Mail.ru Cloud Solutions-ում