Exempel på en event-driven applikation baserad på webbhooks i Mail.ru Cloud Solutions S3-lagring

Rube Goldberg-kaffemaskin

Händelsedriven arkitektur ökar kostnadseffektiviteten för de resurser som används, eftersom de används endast när de behövs. Det finns många sätt att implementera detta utan att skapa extra molnresurser som worker-applikationer. Idag kommer jag inte att prata om FaaS, utan om webhooks. Jag kommer att visa ett exempel på händelsebehandling med hjälp av webhooks från objektlagring.

Ett par ord om objektlagring och webhooks. Objektlagring gör det möjligt att lagra vilken data som helst i molnet som objekt, som är tillgängliga via S3 eller annan API (beroende på implementation) över HTTP/HTTPS. Webhooks är i allmänhet användardefinierade omvända anrop via HTTP. De utlöses vanligtvis av en händelse, till exempel när kod skickas till ett repository eller en kommentar publiceras i en blogg. När en händelse inträffar, skickar den ursprungliga webbplatsen en HTTP-förfrågan till den URL som anges för webhook. Som ett resultat kan händelser på en webbplats utlösa åtgärder på en annan. I det här fallet, när objektlagring fungerar som den ursprungliga webbplatsen, är förändringar i dess innehåll händelser.wiki). När källwebbplatsen är ett objektlagringssystem, utgör ändringar i dess innehåll händelser.

Exempel på enklare fall där sådan automatisering kan användas:

1. Skapa kopior av alla objekt i en annan molnlagring. Kopiorna ska skapas "på flygande fot", vid varje tillägg eller ändring av filer.
2. Automatisk skapelse av serier av miniatyrbilder av grafiska filer, tillägg av vattenstämplar på foton, andra modifieringar av bilder.
3. Notifiering om ankomsten av nya dokument (till exempel, en distribuerad bokföringsavdelning laddar upp rapporter till molnet, och finansiell övervakning får aviseringar om nya rapporter, kontrollerar och analyserar dem).
4. Lite mer komplexa fall innebär exempelvis att generera en förfrågan till Kubernetes, som skapar en pod med nödvändiga containrar, överför uppgiftens parametrar och sedan avvecklar containern efter bearbetningen.

Som ett exempel kommer vi att göra en variant av uppgift 1 där ändringar i objektlagringen Mail.ru Cloud Solutions (MCS) synkroniseras till AWS objektlagring med hjälp av webhooks. I verkliga tunga fall bör man tänka på asynkron drift genom att registrera webhooks i en kö, men för den här övningsuppgiften gör vi en implementation utan det.

Arbetsdiagram

Protokollet för interaktion beskrivs i detalj i manualen för S3-webhooks på MCS. Arbetsdiagrammet innehåller följande element:

• Publiseringstjänst, som finns på sidan av S3-lagringen och publicerar HTTP-förfrågningar när webhooken utlöses.
• Webhook-mottagarserver, som lyssnar på förfrågningar från publiseringstjänsten via HTTP och utför lämpliga åtgärder. Servern kan skrivas på vilket språk som helst, i vårt exempel kommer vi att skriva servern på Go.

En specifik funktion av implementeringen av webhooks i S3 API är registreringen av webhook-mottagarservern på publiseringstjänsten. Specifikt måste webhook-mottagarservern bekräfta prenumerationen på meddelanden från publiseringstjänsten (i andra implementationer av webhooks krävs vanligtvis inte prenumerationsbekräftelse).

Därför måste webhook-mottagarservern stödja två grundläggande operationer:

• bekräfta publikationsservicens begäran om registreringsbekräftelse,
• behandla inkommande händelser.

Installation av webhook-mottagarserver

För att köra webhook-mottagarservern behöver vi en Linux-server. I denna artikel använder vi för exempel en virtuell instans som vi implementerar på MCS.

Låt oss installera nödvändig programvara och starta webhook-mottagarservern.

ubuntu@ubuntu-basic-1-2-10gb:~$ sudo apt-get install git
Läser paketlistor... Klar
Bygger beroendeträd
Läser tillståndsinformation... Klar
Följande paket har installerats automatiskt och krävs inte längre:
 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
Använd 'sudo apt autoremove' för att ta bort dem.
Föreslagna paket:
 git-daemon-run | git-daemon-sysvinit git-doc git-el git-email git-gui 
gitk gitweb git-cvs git-mediawiki git-svn
Följande NYA paket kommer att installeras:
 git
0 uppgraderade, 1 nyinstallerad, 0 att ta bort och 46 inte uppgraderade.
Behöver hämta 3915 kB av arkiv.
Efter den här åtgärden kommer 32.3 MB extra diskutrymme att användas.
Hämtar:1 http://MS1.clouds.archive.ubuntu.com/ubuntu bionic-updates/main 
amd64 git amd64 1:2.17.1-1ubuntu0.7 [3915 kB]
Hämtade 3915 kB på 1s (5639 kB/s)
Väljer tidigare ickevalt paket git.
(Läser databasen ... 53932 filer och mappar är för närvarande installerade.)
Förbereder att packa upp .../git_12.17.1-1ubuntu0.7_amd64.deb ...
Packar upp git (1:2.17.1-1ubuntu0.7) ...
Ställer in git (1:2.17.1-1ubuntu0.7) ...

Klonar mappen med webhook-mottagarservern:

ubuntu@ubuntu-basic-1-2-10gb:~$ git clone
https://github.com/RomanenkoDenys/s3-webhook.git
Klonar in i 's3-webhook'...
remote: Uppräkning av objekt: 48, klar.
remote: Räkna objekt: 100% (48/48), klar.
remote: Komprimering av objekt: 100% (27/27), klar.
remote: Totalt 114 (delta 20), återanvänd 45 (delta 18), packade om 66
Mottar objekt: 100% (114/114), 23.77 MiB | 20.25 MiB/s, klar.
Löser skillnader: 100% (49/49), klar.

Vi startar servern:

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

Prenumeration av publiceringstjänst

Du kan registrera din webbhook-server antingen via API eller webgränssnitt. För enkelhetens skull registrerar vi via webgränssnittet:

1. Gå till avsnittet för bucketar i kontrollpanelen.
2. Gå in i bucketen för vilken vi ska konfigurera webhooks, och klicka på kugghjulet:

Gå till fliken Webhooks och klicka på Lägg till:

Fyll i fälten:

ID - namnet på webhooken.

Event - vilka händelser som ska överföras. Vi har angett att överföra alla händelser som inträffar vid hantering av filer (tillägg och borttagning).

URL - adressen till webbhook-mottagarservern.

Filter prefix/suffix - filter som gör att webhooks genereras endast för objekt vars namn följer vissa regler. Till exempel, för att webhooken ska utlösas endast för filer med filtillägget .png, behöver du i Filter suffix skriva "png".

För närvarande stöds endast portar 80 och 443 för kommunikation med webbhook-mottagarservern.

Vi klickar på Lägg till hook och ser följande:

Hook har lagts till.

Webbhook-mottagarservern visar i loggarna att registreringen av hooken genomfördes:

ubuntu@ubuntu-basic-1-2-10gb:~/s3-webhook$ sudo ./s3-webhook -port 80
2020/06/15 12:01:14 [POST] inkommande HTTP-förfrågan från 
95.163.216.92:42530
2020/06/15 12:01:14 Fick tidsstämpel: 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 Generera respons-signatur: 
3754ce36636f80dfd606c5254d64ecb2fd8d555c27962b70b4f759f32c76b66d

Registreringen är avslutad. I nästa avsnitt kommer vi att titta mer detaljerat på hur webbhook-mottagarservern fungerar.

Beskrivning av webbhook-mottagarservern

I vårt exempel är servern skriven i Go. Låt oss gå igenom de grundläggande principerna för dess funktion.

package main

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

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

// Skicka bekräftelse av prenumerationen
func SubscriptionConfirmation(w http.ResponseWriter, req *http.Request, body []byte) {
}

// Ta emot registreringar
func GotRecords(w http.ResponseWriter, req *http.Request, body []byte) {
}

// Hälsokontroll
func Ping(w http.ResponseWriter, req *http.Request) {
    // logga förfrågan
    log.Printf("[%s] inkommande HTTP Ping-förfrågan från %sn", req.Method, req.RemoteAddr)
    fmt.Fprintf(w, "Pongn")
}

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

func main() {

    // hämta kommandoradsargument
    bindPort := flag.Int("port", 80, "nummer mellan 1-65535")
    bindAddr := flag.String("address", "", "IP-adress i punktformat")
    flag.StringVar(&actionScript, "script", "", "extern skript att köra")
    flag.Parse()

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

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

Låt oss titta på huvudfunktionerna:

• Ping() — en rutt som svarar på URL/ping, en enkel implementering av liveness probe.
• Webhook() — huvudrutten, hanterare av URL/webhook:
  • bekräftar registreringen på publiceringstjänsten (går över till funktionen SubscriptionConfirmation),
  • hanterar inkommande webhooks (funktionen Gotrecords).
• Funktionerna HmacSha256 och HmacSha256hex — implementeringar av HMAC-SHA256- och HMAC-SHA256-algoritmerna som ger utdata i form av hexadecimalsträngar för signaturberäkning.
• main — huvudfunktionen, hanterar kommandoradsparametrar och registrerar URL-hanterare.

Kommandoradsparametrar som servern tar emot:

• -port — porten som servern kommer att lyssna på.
• -address — IP-adressen som servern kommer att lyssna på.
• -script — ett externt program som anropas för varje inkommande hook.

Låt oss titta närmare på vissa funktioner:

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

}

Denna funktion avgör vad som har kommit — en begäran om registreringsbekräftelse eller en webhook. Som framgår av dokumentationen, i händelse av registreringsbekräftelse kommer följande JSON-struktur i POST-begäran:

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":"Du har valt att prenumerera på ämnet $topic. För att bekräfta prenumerationen behöver du svara med den beräknade signaturen",
    "TopicArn":"mcs2883541269|bucketA|s3:ObjectCreated:Put",
    "SignatureVersion":1,
    "Token":«RPE5UuG94rGgBH6kHXN9FUPugFxj1hs2aUQc99btJp3E49tA»
}

Detta svarar på begäran:

content-type: application/json

{"signature":«ea3fce4bb15c6de4fec365d36bcebbc34ccddf54616d5ca12e1972f82b6d37af»}

Där signaturen beräknas som:

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

Om det kommer en webhook ser POST-begärans struktur ut så här:

POST  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"
            }
        }
    ]
}

Därmed, beroende på begäran, måste vi förstå hur vi ska bearbeta data. Jag valde att använda postningen "Type":"SubscriptionConfirmation", eftersom den finns i begäran om bekräftelse av prenumerationen och inte finns i webhooken. Beroende på närvaron/frånvaron av denna post i POST-begäran fortsätter programmets utförande antingen till funktionen SubscriptionConfirmation, eller till funktionen GotRecords.

Vi kommer inte att granska funktionen SubscriptionConfirmation i detalj, den är implementerad enligt de principer som beskrivs i dokumentationen. Den ursprungliga koden för denna funktion kan studeras i git-repositoriet för projektet.

Funktionen GotRecords analyserar den inkommande begäran och för varje objekt Record anropar ett externt skript (namnet på vilket som överfördes i parametern -script) med parametrarna:

• bucket-namn
• objektnyckel
• åtgärd:
  • copy — om EventName = ObjectCreated | PutObject | PutObjectCopy i den ursprungliga begäran
  • delete — om EventName = ObjectRemoved | DeleteObject i den ursprungliga begäran

Således, om en webhook har kommit med en POST-begäran, som beskrivs metoden., och parametern -script=script.sh, kommer skriptet att anropas på följande sätt:

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

Det är viktigt att förstå att den här servern för mottagande av webhooks — inte är en färdig produktionslösning, utan ett förenklat exempel på en möjlig implementering.

Exempel på arbete

Vi kommer att synkronisera filer från huvud-bucket i MCS till en reserv-bucket i AWS. Huvud-bucket kallas myfiles-ash, reserv-bucket — myfiles-backup (konfiguration av bucketen i AWS ligger utanför denna artikel). Därför, när en fil placeras i huvud-bucket, ska en kopia av den dyka upp i reserv-bucket, och när den tas bort från huvud-bucket — tas den bort i reserv-bucket.

Vi kommer att arbeta med bucketer genom verktyget awscli, som är kompatibelt med både MCS molnlagring och AWS molnlagring.

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

Låt oss konfigurera åtkomst till API S3 MCS:

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]:

Låt oss konfigurera åtkomst till API S3 AWS:

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]:

Låt oss kontrollera åtkomster:

Till AWS:

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

För MCS, måste kommandot läggas till —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

Åtkomst beviljad.

Nu skriver vi ett skript för att hantera den inkommande händelsen, vi kallar det 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="${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

Startar servern:

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

Vi kontrollerar hur detta fungerar. Genom MCS webbgränssnitt lägger vi till filen test.txt i bucket myfiles-ash. I loggarna i konsolen syns det att en begäran har gjorts till webhook-servern:

2020\/07\/06 09:43:08 [POST] inkommande HTTP-begäran från 
95.163.216.92:56612
download: s3:\/\/myfiles-ash\/test.txt till ..\/..\/..\/tmp\/myfiles-ash\/test.txt
upload: ..\/..\/..\/tmp\/myfiles-ash\/test.txt till 
s3:\/\/myfiles-backup\/test.txt

Låt oss kontrollera innehållet i bucket myfiles-backup i 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

Nu tar vi bort filen från bucket myfiles-ash genom webbgränssnittet.

Serverloggar:

2020\/07\/06 09:44:46 [POST] inkommande HTTP-begäran från 
95.163.216.92:58224
delete: s3:\/\/myfiles-backup\/test.txt

Innehållet i bucketen:

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

Filen har tagits bort, problemet löst.

Slutsats och ToDo

All kod som används i denna artikel ligger här i mitt förråd. Där finns också exempel på skript och exempel på beräkning av signaturer för registrering av webhooks.

Denna kod är inget mer än ett exempel på hur man kan använda S3-webhooks i sin verksamhet. Som jag sa i början, om man planerar att använda en sådan server i produktion, bör man åtminstone skriva om servern för asynkron drift: inkommande webhooks registreras i en kö (RabbitMQ eller NATS), och därifrån bearbetas de av arbetande applikationer. Annars kan man vid massiv ankomst av webhooks stöta på brist på serverresurser för att utföra uppgifter. Att ha köer tillåter att sprida servern och arbetarna, samt att lösa problem med upprepning av uppgifter vid fel. Det är också önskvärt att förändra loggningen till mer detaljerad och mer standardiserad.

Lycka till!

Läs mer om ämnet:

• Arbetar med objektbaserad S3-lagring från Mail.ru Cloud Solutions som med ett filsystem.
• Hur man använder objektlagring för att överträffa konkurrenter.

Källa: habr.com