Mail.ru ਕਲਾਉਡ ਸੋਲਿਊਸ਼ਨਜ਼ ਦੇ S3 ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਵਿੱਚ ਵੈਬਹੁੱਕਾਂ 'ਤੇ ਆਧਾਰਿਤ ਇੱਕ ਇਵੈਂਟ-ਸੰਚਾਲਿਤ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਇੱਕ ਉਦਾਹਰਨ

ਰੂਬ ਗੋਲਡਬਰਗ ਕੌਫੀ ਮਸ਼ੀਨ

ਇਵੈਂਟ-ਸੰਚਾਲਿਤ ਆਰਕੀਟੈਕਚਰ ਵਰਤੇ ਗਏ ਸਰੋਤਾਂ ਦੀ ਲਾਗਤ ਕੁਸ਼ਲਤਾ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਉਹ ਉਦੋਂ ਹੀ ਕਿਰਿਆਸ਼ੀਲ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਉਹਨਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ ਅਤੇ ਵਰਕਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਤੌਰ 'ਤੇ ਵਾਧੂ ਕਲਾਉਡ ਇਕਾਈਆਂ ਨੂੰ ਕਿਵੇਂ ਨਹੀਂ ਬਣਾਉਣਾ ਹੈ ਇਸ ਲਈ ਬਹੁਤ ਸਾਰੇ ਵਿਕਲਪ ਹਨ। ਅਤੇ ਅੱਜ ਮੈਂ FaaS ਬਾਰੇ ਨਹੀਂ, ਪਰ ਵੈਬਹੁੱਕ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗਾ। ਮੈਂ ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਵੈਬਹੁੱਕ ਨਾਲ ਇਵੈਂਟ ਹੈਂਡਲਿੰਗ ਦਾ ਕੇਸ ਸਟੱਡੀ ਦਿਖਾਵਾਂਗਾ।

ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਅਤੇ ਵੈਬਹੁੱਕ ਬਾਰੇ ਕੁਝ ਸ਼ਬਦ। ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਤੁਹਾਨੂੰ S3 ਜਾਂ ਕਿਸੇ ਹੋਰ API (ਲਾਗੂ ਕਰਨ 'ਤੇ ਨਿਰਭਰ) ਦੁਆਰਾ HTTP/HTTPS ਦੁਆਰਾ ਉਪਲਬਧ ਵਸਤੂਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਕਲਾਉਡ ਵਿੱਚ ਕਿਸੇ ਵੀ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਵੈਬਹੁੱਕ ਆਮ ਤੌਰ 'ਤੇ ਕਸਟਮ HTTP ਕਾਲਬੈਕ ਹੁੰਦੇ ਹਨ। ਉਹ ਆਮ ਤੌਰ 'ਤੇ ਕਿਸੇ ਇਵੈਂਟ ਦੁਆਰਾ ਸ਼ੁਰੂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ ਰਿਪੋਜ਼ਟਰੀ ਲਈ ਕੋਡ ਪੁਸ਼ ਜਾਂ ਬਲੌਗ 'ਤੇ ਪੋਸਟ ਕੀਤੀ ਟਿੱਪਣੀ। ਜਦੋਂ ਕੋਈ ਇਵੈਂਟ ਵਾਪਰਦਾ ਹੈ, ਤਾਂ ਮੂਲ ਸਾਈਟ ਵੈਬਹੁੱਕ ਲਈ ਨਿਰਦਿਸ਼ਟ URL ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਭੇਜਦੀ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ, ਤੁਸੀਂ ਇੱਕ ਸਾਈਟ 'ਤੇ ਇਵੈਂਟ ਬਣਾ ਸਕਦੇ ਹੋ, ਦੂਜੀ 'ਤੇ ਕਾਰਵਾਈਆਂ ਨੂੰ ਟਰਿੱਗਰ ਕਰ ਸਕਦੇ ਹੋ (ਵਿਕਿ). ਅਜਿਹੀ ਸਥਿਤੀ ਵਿੱਚ ਜਦੋਂ ਸਰੋਤ ਸਾਈਟ ਇੱਕ ਵਸਤੂ ਸਟੋਰੇਜ ਹੁੰਦੀ ਹੈ, ਇਸਦੀ ਸਮੱਗਰੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਘਟਨਾਵਾਂ ਦੇ ਤੌਰ ਤੇ ਕੰਮ ਕਰਦੀਆਂ ਹਨ।

ਸਧਾਰਨ ਕੇਸਾਂ ਦੀਆਂ ਉਦਾਹਰਨਾਂ ਜਿੱਥੇ ਅਜਿਹੇ ਆਟੋਮੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ:

1. ਕਿਸੇ ਹੋਰ ਕਲਾਉਡ ਸਟੋਰੇਜ ਵਿੱਚ ਸਾਰੀਆਂ ਵਸਤੂਆਂ ਦੀਆਂ ਕਾਪੀਆਂ ਬਣਾਓ। ਫਾਈਲਾਂ ਦੇ ਕਿਸੇ ਵੀ ਜੋੜ ਜਾਂ ਤਬਦੀਲੀ ਦੇ ਨਾਲ ਕਾਪੀਆਂ "ਉੱਡਦੇ ਹੀ" ਬਣਾਈਆਂ ਜਾਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ।
2. ਗ੍ਰਾਫਿਕ ਫਾਈਲਾਂ ਦੇ ਥੰਬਨੇਲ ਦੀ ਇੱਕ ਲੜੀ ਦੀ ਆਟੋਮੈਟਿਕ ਰਚਨਾ, ਫੋਟੋਆਂ ਵਿੱਚ ਵਾਟਰਮਾਰਕ ਜੋੜਨਾ, ਹੋਰ ਚਿੱਤਰ ਸੋਧਾਂ।
3. ਨਵੇਂ ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਆਮਦ ਬਾਰੇ ਸੂਚਨਾ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਵੰਡੀ ਲੇਖਾਕਾਰੀ ਸੇਵਾ ਕਲਾਉਡ 'ਤੇ ਰਿਪੋਰਟਾਂ ਅੱਪਲੋਡ ਕਰਦੀ ਹੈ, ਅਤੇ ਵਿੱਤੀ ਨਿਗਰਾਨੀ ਨਵੀਆਂ ਰਿਪੋਰਟਾਂ ਬਾਰੇ ਸੂਚਨਾਵਾਂ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ, ਉਹਨਾਂ ਦੀ ਜਾਂਚ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦੀ ਹੈ)।
4. ਥੋੜ੍ਹਾ ਹੋਰ ਗੁੰਝਲਦਾਰ ਕੇਸਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਕੁਬਰਨੇਟਸ ਨੂੰ ਇੱਕ ਬੇਨਤੀ ਤਿਆਰ ਕਰਨਾ, ਜੋ ਲੋੜੀਂਦੇ ਕੰਟੇਨਰਾਂ ਨਾਲ ਇੱਕ ਪੌਡ ਬਣਾਉਂਦਾ ਹੈ, ਇਸ ਵਿੱਚ ਕਾਰਜ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਪਾਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਪ੍ਰੋਸੈਸਿੰਗ ਤੋਂ ਬਾਅਦ ਕੰਟੇਨਰ ਨੂੰ ਸਮੇਟਦਾ ਹੈ।

ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਟਾਸਕ 1 ਦਾ ਇੱਕ ਰੂਪ ਬਣਾਵਾਂਗੇ, ਜਦੋਂ ਵੈਬਹੁੱਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Mail.ru ਕਲਾਊਡ ਸੋਲਿਊਸ਼ਨ (MCS) ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਬਕੇਟ ਵਿੱਚ ਬਦਲਾਅ AWS ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਵਿੱਚ ਸਮਕਾਲੀ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇੱਕ ਅਸਲ ਲੋਡ ਕੀਤੇ ਕੇਸ ਵਿੱਚ, ਇੱਕ ਕਤਾਰ ਵਿੱਚ ਵੈਬਹੁੱਕਾਂ ਨੂੰ ਰਜਿਸਟਰ ਕਰਕੇ ਅਸਿੰਕ੍ਰੋਨਸ ਕੰਮ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਪਰ ਸਿਖਲਾਈ ਕਾਰਜ ਲਈ ਅਸੀਂ ਇਸਦੇ ਬਿਨਾਂ ਲਾਗੂ ਕਰਾਂਗੇ।

ਕੰਮ ਦੀ ਯੋਜਨਾ

ਇੰਟਰਐਕਸ਼ਨ ਪ੍ਰੋਟੋਕੋਲ ਵਿੱਚ ਵਿਸਥਾਰ ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ MCS 'ਤੇ S3 ਵੈਬਹੁੱਕ ਲਈ ਗਾਈਡ. ਕੰਮ ਦੀ ਯੋਜਨਾ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਤੱਤ ਹਨ:

• ਪਬਲਿਸ਼ਿੰਗ ਸੇਵਾ, ਜੋ ਕਿ S3 ਸਟੋਰੇਜ ਦੇ ਪਾਸੇ ਹੈ ਅਤੇ ਜਦੋਂ ਵੈਬਨਹੂਕ ਫਾਇਰ ਹੁੰਦਾ ਹੈ ਤਾਂ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।
• ਵੈਬਹੁੱਕ ਸਰਵਰA ਜੋ HTTP ਉੱਤੇ ਪ੍ਰਕਾਸ਼ਨ ਸੇਵਾ ਤੋਂ ਬੇਨਤੀਆਂ ਨੂੰ ਸੁਣਦਾ ਹੈ ਅਤੇ ਉਚਿਤ ਕਾਰਵਾਈ ਕਰਦਾ ਹੈ। ਸਰਵਰ ਨੂੰ ਕਿਸੇ ਵੀ ਭਾਸ਼ਾ ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਸਾਡੀ ਉਦਾਹਰਣ ਵਿੱਚ ਅਸੀਂ ਸਰਵਰ ਨੂੰ ਗੋ ਵਿੱਚ ਲਿਖਾਂਗੇ।

S3 API ਵਿੱਚ ਵੈਬਹੁੱਕ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਪ੍ਰਕਾਸ਼ਨ ਸੇਵਾ 'ਤੇ ਵੈਬਹੁੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਰਵਰ ਦੀ ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਵੈਬਹੁੱਕ ਰਿਸੀਵਰ ਸਰਵਰ ਨੂੰ ਪਬਲਿਸ਼ ਸੇਵਾ ਸੁਨੇਹਿਆਂ ਦੀ ਗਾਹਕੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ (ਹੋਰ ਵੈਬਹੁੱਕ ਲਾਗੂਕਰਨਾਂ ਵਿੱਚ, ਆਮ ਤੌਰ 'ਤੇ ਗਾਹਕੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ)।

ਇਸ ਅਨੁਸਾਰ, ਵੈਬਹੁੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਰਵਰ ਨੂੰ ਦੋ ਮੁੱਖ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਸਮਰਥਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ:

• ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਪੁਸ਼ਟੀ ਲਈ ਪ੍ਰਕਾਸ਼ਨ ਸੇਵਾ ਦੀ ਬੇਨਤੀ ਦਾ ਜਵਾਬ ਦੇਣਾ,
• ਆਉਣ ਵਾਲੀਆਂ ਘਟਨਾਵਾਂ ਨੂੰ ਸੰਭਾਲਣਾ।

ਇੱਕ ਵੈਬਹੁੱਕ ਰਿਸੀਵਰ ਸੈੱਟਅੱਪ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਵੈਬਹੁੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਰਵਰ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ Linux ਸਰਵਰ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਲੇਖ ਵਿੱਚ, ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਵਰਚੁਅਲ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਜਿਸਨੂੰ ਅਸੀਂ MCS 'ਤੇ ਤੈਨਾਤ ਕਰਦੇ ਹਾਂ।

ਲੋੜੀਂਦੇ ਸੌਫਟਵੇਅਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ ਅਤੇ ਵੈਬਹੁੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਰਵਰ ਨੂੰ ਚਾਲੂ ਕਰੋ।

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 ਜਾਂ ਵੈੱਬ ਇੰਟਰਫੇਸ ਰਾਹੀਂ ਆਪਣੇ ਵੈਬਹੁੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਰਵਰ ਨੂੰ ਰਜਿਸਟਰ ਕਰ ਸਕਦੇ ਹੋ। ਸਰਲਤਾ ਲਈ, ਅਸੀਂ ਵੈੱਬ ਇੰਟਰਫੇਸ ਰਾਹੀਂ ਰਜਿਸਟਰ ਕਰਾਂਗੇ:

1. ਬਾਲਟੀਆਂ ਦੇ ਭਾਗ 'ਤੇ ਜਾਓ ਕੰਟਰੋਲ ਰੂਮ ਵਿੱਚ.
2. ਅਸੀਂ ਬਾਲਟੀ ਵਿੱਚ ਜਾਂਦੇ ਹਾਂ, ਜਿਸ ਲਈ ਅਸੀਂ ਵੈਬਹੁੱਕ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਾਂਗੇ, ਅਤੇ ਗੇਅਰ 'ਤੇ ਕਲਿੱਕ ਕਰਾਂਗੇ:

Webhooks ਟੈਬ 'ਤੇ ਜਾਓ ਅਤੇ ਸ਼ਾਮਲ ਕਰੋ 'ਤੇ ਕਲਿੱਕ ਕਰੋ:

ਖੇਤਰ ਭਰੋ:

ID - ਵੈੱਬਹੁੱਕ ਦਾ ਨਾਮ।

ਇਵੈਂਟ - ਕਿਹੜੀਆਂ ਘਟਨਾਵਾਂ ਭੇਜਣੀਆਂ ਹਨ। ਅਸੀਂ ਉਹਨਾਂ ਸਾਰੀਆਂ ਘਟਨਾਵਾਂ ਦਾ ਪ੍ਰਸਾਰਣ ਸੈਟ ਕਰਦੇ ਹਾਂ ਜੋ ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਵਾਪਰਦੀਆਂ ਹਨ (ਜੋੜਨ ਅਤੇ ਹਟਾਉਣਾ)।

URL - ਵੈਬਹੁੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਰਵਰ ਦਾ ਪਤਾ।

ਫਿਲਟਰ ਪ੍ਰੀਫਿਕਸ/ਪਿਛੇਤਰ - ਇੱਕ ਫਿਲਟਰ ਜੋ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਉਹਨਾਂ ਵਸਤੂਆਂ ਲਈ ਵੈਬਹੁੱਕ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਦੇ ਨਾਮ ਕੁਝ ਨਿਯਮਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਵੈੱਬਹੁੱਕ ਨੂੰ ਸਿਰਫ਼ .png ਐਕਸਟੈਂਸ਼ਨ ਵਾਲੀਆਂ ਫਾਈਲਾਂ 'ਤੇ ਕੰਮ ਕਰਨ ਲਈ, ਇਨ ਫਿਲਟਰ ਪਿਛੇਤਰ ਤੁਹਾਨੂੰ "png" ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ।

ਵਰਤਮਾਨ ਵਿੱਚ, ਵੈਬਹੁੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਰਵਰ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਸਿਰਫ਼ ਪੋਰਟ 80 ਅਤੇ 443 ਸਮਰਥਿਤ ਹਨ।

ਚਲੋ ਦਬਾਓ ਹੁੱਕ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ ਅਸੀਂ ਹੇਠ ਲਿਖਿਆਂ ਨੂੰ ਵੇਖਾਂਗੇ:

ਹੁੱਕ ਜੋੜਿਆ ਗਿਆ।

ਲੌਗਸ ਵਿੱਚ ਵੈਬਹੁੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲਾ ਸਰਵਰ ਹੁੱਕ ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਦੀ ਪ੍ਰਗਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ:

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

ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਖਤਮ ਹੋ ਗਈ ਹੈ। ਅਗਲੇ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਵੈਬਹੁੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਸਰਵਰ ਦੇ ਐਲਗੋਰਿਦਮ ਬਾਰੇ ਵਧੇਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਵਿਚਾਰ ਕਰਾਂਗੇ।

ਵੈਬਹੁੱਕ ਸਰਵਰ ਦਾ ਵੇਰਵਾ

ਸਾਡੀ ਉਦਾਹਰਣ ਵਿੱਚ, ਸਰਵਰ ਗੋ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ। ਆਉ ਇਸਦੇ ਕੰਮ ਦੇ ਮੂਲ ਸਿਧਾਂਤਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੀਏ.

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

ਮੁੱਖ ਫੰਕਸ਼ਨਾਂ 'ਤੇ ਗੌਰ ਕਰੋ:

• ਪਿੰਗ () - ਇੱਕ ਰੂਟ ਜੋ ਇੱਕ URL / ਪਿੰਗ ਦਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਇੱਕ ਲਾਈਵਨੈੱਸ ਪੜਤਾਲ ਦਾ ਸਭ ਤੋਂ ਸਰਲ ਲਾਗੂਕਰਨ।
• ਵੈਬਹੁੱਕ () - ਮੁੱਖ ਰੂਟ, URL/ਵੈਬਹੁੱਕ ਹੈਂਡਲਰ:
  • ਪ੍ਰਕਾਸ਼ਨ ਸੇਵਾ 'ਤੇ ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ (ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਪੁਸ਼ਟੀਕਰਣ ਫੰਕਸ਼ਨ 'ਤੇ ਜਾਣਾ),
  • ਇਨਕਮਿੰਗ ਵੈਬਹੁੱਕ (ਗੋਰਕਾਰਡ ਫੰਕਸ਼ਨ) ਨੂੰ ਹੈਂਡਲ ਕਰਦਾ ਹੈ।
• HmacSha256 ਅਤੇ HmacSha256hex ਫੰਕਸ਼ਨ HMAC-SHA256 ਅਤੇ HMAC-SHA256 ਏਨਕ੍ਰਿਪਸ਼ਨ ਐਲਗੋਰਿਦਮ ਦੇ ਲਾਗੂ ਹਨ ਜੋ ਦਸਤਖਤ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਹੈਕਸਾਡੈਸੀਮਲ ਨੰਬਰਾਂ ਦੀ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਆਉਟਪੁੱਟ ਦੇ ਨਾਲ ਹਨ।
• main ਮੁੱਖ ਫੰਕਸ਼ਨ ਹੈ, ਕਮਾਂਡ ਲਾਈਨ ਵਿਕਲਪਾਂ ਨੂੰ ਹੈਂਡਲ ਕਰਦਾ ਹੈ ਅਤੇ URL ਹੈਂਡਲਰ ਨੂੰ ਰਜਿਸਟਰ ਕਰਦਾ ਹੈ।

ਸਰਵਰ ਦੁਆਰਾ ਸਵੀਕਾਰ ਕੀਤੇ ਕਮਾਂਡ ਲਾਈਨ ਵਿਕਲਪ:

• -ਪੋਰਟ ਉਹ ਪੋਰਟ ਹੈ ਜਿਸ 'ਤੇ ਸਰਵਰ ਸੁਣੇਗਾ।
• -ਐਡਰੈੱਸ ਉਹ 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 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 <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.

ਅਸੀਂ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਪੁਸ਼ਟੀਕਰਣ ਫੰਕਸ਼ਨ ਨੂੰ ਵਿਸਥਾਰ ਵਿੱਚ ਨਹੀਂ ਵਿਚਾਰਾਂਗੇ; ਇਹ ਇਸ ਵਿੱਚ ਦਿੱਤੇ ਸਿਧਾਂਤਾਂ ਦੇ ਅਨੁਸਾਰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ ਦਸਤਾਵੇਜ਼. ਤੁਸੀਂ ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਸਰੋਤ ਕੋਡ 'ਤੇ ਦੇਖ ਸਕਦੇ ਹੋ ਪ੍ਰੋਜੈਕਟ git ਰਿਪੋਜ਼ਟਰੀਆਂ.

GotRecords ਫੰਕਸ਼ਨ ਆਉਣ ਵਾਲੀ ਬੇਨਤੀ ਨੂੰ ਪਾਰਸ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਰਿਕਾਰਡ ਆਬਜੈਕਟ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਪੈਰਾਮੀਟਰਾਂ ਨਾਲ ਇੱਕ ਬਾਹਰੀ ਸਕ੍ਰਿਪਟ (ਜਿਸਦਾ ਨਾਮ -script ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਗਿਆ ਸੀ) ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ:

• ਬਾਲਟੀ ਦਾ ਨਾਮ
• ਵਸਤੂ ਕੁੰਜੀ
• ਕਾਰਵਾਈ:
  • ਕਾਪੀ - ਜੇਕਰ ਅਸਲ ਬੇਨਤੀ ਵਿੱਚ ਹੈ EventName = ObjectCreated | ਪੁਟ ਆਬਜੈਕਟ | ਪੁਟ ਆਬਜੈਕਟ ਕਾਪੀ
  • ਮਿਟਾਓ - ਜੇਕਰ ਅਸਲ ਬੇਨਤੀ ਵਿੱਚ ਹੈ EventName = ObjectRemoved | ਡਿਲੀਟ ਆਬਜੈਕਟ

ਇਸ ਤਰ੍ਹਾਂ, ਜੇ ਇੱਕ ਹੁੱਕ ਪੋਸਟ ਬੇਨਤੀ ਦੇ ਨਾਲ ਆਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਦੱਸਿਆ ਗਿਆ ਹੈ ਉੱਚ, ਅਤੇ ਪੈਰਾਮੀਟਰ -script=script.sh ਫਿਰ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕਿਹਾ ਜਾਵੇਗਾ:

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

ਇਹ ਸਮਝਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇਹ ਵੈਬਹੁੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲਾ ਸਰਵਰ ਇੱਕ ਸੰਪੂਰਨ ਉਤਪਾਦਨ ਹੱਲ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ ਸੰਭਾਵੀ ਲਾਗੂ ਕਰਨ ਦੀ ਇੱਕ ਸਰਲ ਉਦਾਹਰਣ ਹੈ.

ਕੰਮ ਦੀ ਉਦਾਹਰਨ

ਆਉ 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 ਬਾਲਟੀ ਵਿੱਚ ਜੋੜੋ। ਕੰਸੋਲ ਵਿੱਚ ਲੌਗ ਦਿਖਾਉਂਦੇ ਹਨ ਕਿ ਵੈਬਹੁੱਕ ਸਰਵਰ ਨੂੰ ਬੇਨਤੀ ਕੀਤੀ ਗਈ ਸੀ:

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

ਆਓ AWS ਵਿੱਚ myfiles-ਬੈਕਅੱਪ ਬਾਲਟੀ ਦੀਆਂ ਸਮੱਗਰੀਆਂ ਦੀ ਜਾਂਚ ਕਰੀਏ:

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

ਹੁਣ, ਵੈੱਬ ਇੰਟਰਫੇਸ ਰਾਹੀਂ, ਮਾਈਫਾਇਲ-ਐਸ਼ ਬਾਲਟੀ ਤੋਂ ਫਾਈਲ ਨੂੰ ਮਿਟਾਓ।

ਸਰਵਰ ਲੌਗਸ:

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), ਅਤੇ ਉੱਥੋਂ ਉਹਨਾਂ ਨੂੰ ਪਾਰਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਵਰਕਰਾਂ ਦੀਆਂ ਅਰਜ਼ੀਆਂ ਦੁਆਰਾ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਨਹੀਂ ਤਾਂ, ਵੈਬਹੁੱਕ ਦੀ ਵੱਡੀ ਆਮਦ ਦੇ ਨਾਲ, ਤੁਹਾਨੂੰ ਕਾਰਜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਸਰਵਰ ਸਰੋਤਾਂ ਦੀ ਘਾਟ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈ ਸਕਦਾ ਹੈ। ਕਤਾਰਾਂ ਦੀ ਮੌਜੂਦਗੀ ਤੁਹਾਨੂੰ ਸਰਵਰ ਅਤੇ ਕਰਮਚਾਰੀਆਂ ਨੂੰ ਫੈਲਾਉਣ ਦੇ ਨਾਲ-ਨਾਲ ਅਸਫਲਤਾਵਾਂ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਦੁਹਰਾਉਣ ਵਾਲੇ ਕੰਮਾਂ ਦੇ ਨਾਲ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ. ਲੌਗਿੰਗ ਨੂੰ ਵਧੇਰੇ ਵਿਸਤ੍ਰਿਤ ਅਤੇ ਵਧੇਰੇ ਮਿਆਰੀ ਵਿੱਚ ਬਦਲਣਾ ਵੀ ਫਾਇਦੇਮੰਦ ਹੈ।

ਕਾਮਯਾਬੀਆਂ!

ਵਿਸ਼ੇ 'ਤੇ ਹੋਰ ਪੜ੍ਹੋ:

• Mail.ru Cloud Solutions S3 ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਦੇ ਨਾਲ ਇੱਕ ਫਾਈਲ ਸਿਸਟਮ ਵਜੋਂ ਕੰਮ ਕਰਨਾ।
• ਉਹ ਮੁਕਾਬਲੇ ਨੂੰ ਹਰਾਉਣ ਲਈ ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਦੇ ਹਨ।

ਸਰੋਤ: www.habr.com