გაზიარებული საქაღალდეების, კონტაქტების, კალენდრების სრული სინქრონიზაცია Kerio Connect სერვერებს შორის

შუადღე მშვიდობისა, ჰაბრ!

დავალება

ჩემი ორგანიზაცია იყენებს ფოსტის სერვერს, რომელიც დაფუძნებულია Kerio Connect პლატფორმაზე; ფოსტის სერვერები, რომლებიც ემსახურებიან მათ მომხმარებლებს, დამონტაჟებულია სხვადასხვა ქალაქში. თავდაპირველად, არ იყო განაწილებული სტრუქტურა, რადგან დომენები განსხვავდება მესამე დონეზე, რაც მიუთითებს საიტის ქალაქზე. ყველაფერი მუშაობდა და ყველა ბედნიერი იყო. ერთ მშვენიერ დღეს მენეჯმენტმა დაადგინა დავალება, საქმეების საერთო კალენდარი ყველა საიტს შორის!

წინაისტორია

თავდაპირველად, იდეა იყო Kerio Distributed Mail Domain-ის გაზრდა და ის ყველაფერს თავად გააკეთებს. ნათქვამია, შესრულებულია, შეიქმნა განაწილებული დომენი, მაგრამ ის იქ არ იყო, სერვერი მზად იყო კალენდრების, საქაღალდეების, კონტაქტების სინქრონიზაციისთვის - იმავე სერვერზე მდებარე დომენებს შორის, მაგრამ საერთოდ არ აპირებდა მონაცემების სინქრონიზაციას რამდენიმე სერვერს შორის. .

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

პრობლემა პრობლემად გადაიქცა.

რა ვარიანტები იყო

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

წინ რომ ვუყურებ, მე ვიტყვი, რომ მიუხედავად იმისა, რომ Kerio ინახავს ობიექტს ცალკე ფაილად, ეს არ არის ისეთი სულელური, რომ იკითხოს როგორ მუშაობს ფაილური სისტემა ყოველ ჯერზე, როდესაც ობიექტზე წვდომა ხდება.

მას შემდეგ, რაც ბევრი დრო გავატარე ფიქრში, დავხატე ფურცლების თაიგულები „მტრის ტერიტორიის ხელში ჩაგდების“ გეგმებით, დილის 6 საათზე მე მივიღე ორი სწორი გადაწყვეტილება:

• პირველი გადაწყვეტილებაა გააკეთო შენი საქმე და არ ეძებო რამე მესამე მხარის.
• მეორე გამოსავალი არის დაძინება.

უკვე დილით გამეღვიძა ერთი და სწორი ფიქრით, რომელიც რამდენიმე ასომდე შემცირდა - DFS

გადაწყვეტილება

თავად გამოსავალი ასე გამოიყურებოდა

• შეიტანეთ ყველა სერვერი, რომელიც მიიღებს მონაწილეობას სინქრონიზაციაში OS Windows-ში. (ნაწილი იყო Linux-ზე. საჭირო იყო ფოსტის მონაცემების სხვა OS-ში მიგრაცია)
• განსაზღვრეთ დირექტორიების სტრუქტურა, რომლებიც მონაწილეობას მიიღებენ სინქრონიზაციაში - ისინი უნდა იყოს იდენტური.
• განსაზღვრეთ ყველა ფოსტის სერვერი ერთი დომენის ქვეშ ერთი DFS სივრცით.
• შექმენით ზემოთ ნახსენები Kerio განაწილებული დომენი, რადგან ჩემს შემთხვევაში საჭიროა მონაცემთა სინქრონიზაცია, არა მხოლოდ სერვერებს შორის, არამედ დომენებს შორისაც, Kerio სერვერს შეუძლია დამოუკიდებლად გაუმკლავდეს მეორეს. (პირველისგან განსხვავებით)
• დააყენეთ სინქრონიზებული დირექტორიები DFS სივრცის წინააღმდეგ.
• მოიფიქრეთ რაიმე სახის ყავარჯენი (ბოლოს და ბოლოს, ყავარჯნის გარეშე შეუძლებელია)

Реализация

მაგალითი ორ ფოსტის სერვერზე (შეიძლება მეტი)

1. Kerio Distributed Domain

ოსტატი არ მონაწილეობს სინქრონიზაციაში, მაგრამ ეს არ არის აუცილებელი პირობა.

მე არ აღვწერ, თუ როგორ უნდა გავზარდო განაწილებული Kerio დომენი, არაფერია რთული, შეგიძლიათ შეისწავლოთ ოფიციალური მანული

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

შემდეგი, მე მაინტერესებდა გაზიარებული საქაღალდეები, Master სერვერზე შეგიძლიათ მიუთითოთ შემდეგი პარამეტრები:

სპეციფიკური თითოეული დომენისთვის - სერვერი არ ახდენს საჯარო საქაღალდეების სინქრონიზაციას დომენებს შორის

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

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

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

2. Kerio მონაცემთა დირექტორიები

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

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

ახლა თქვენ უნდა იპოვოთ ფოსტის საქაღალდეების ფიზიკური ბილიკები თითოეულ სერვერზე.

საერთოა ყველა დომენისთვის ~DataMailmail#publicСинхронизируемый каталог#msgs
სპეციფიკური თითოეული დომენისთვის ~DataMailmail**Domain**#publicСинхронизируемый каталог#msgs

გთხოვთ გაითვალისწინოთ, რომ ჩვენ არ გავაკეთებთ მთელი დირექტორიას, არამედ მხოლოდ მონაცემთა კონტეინერის სინქრონიზაციას #msgs - თავად ობიექტები ინახება აქ, ყველა სხვა მონაცემი თითოეული სერვერისთვის უნდა იყოს საკუთარი.

3.DFS

მე არ აღვწერ დეტალურად, თუ როგორ უნდა დააკონფიგურიროთ DFS, ამ საკითხზე საკმარისი ინფორმაციაა.

DFS არის როლური სერვისი Windows Server-ში, რომელიც უზრუნველყოფს სხვადასხვა სერვერზე განთავსებული საზიარო საქაღალდეების გაერთიანების შესაძლებლობას.
ბმული MS DFS დოკუმენტთან

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

დაყენების დასასრულს, თქვენ უნდა მიიღოთ შემდეგი სურათი თითოეული სინქრონიზებული საქაღალდესთვის

ჩვენ ბუნებრივია არ გვჭირდება განმეორებითი საქაღალდეების გამოქვეყნება.

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

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

4. ყავარჯენი

ასახვის აღწერა

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

სასოწარკვეთილი არ ღირს, რა თქმა უნდა, ადრე თუ გვიან ის იქ გამოჩნდება, მაგრამ უკეთესი ადრე, ვიდრე გვიან. იმიტომ რომ 6-12 საათში გვიანია.

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

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

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

როგორ შეიძლება რომ იყოს?

თუ კიდევ ერთხელ მიაქცევთ ყურადღებას სურათს უკვე ვიცით.

მაგრამ სხვა თვითმფრინავში შეგიძლიათ ნახოთ ჩვენთვის ძალიან საინტერესო და საჭირო ღილაკი - საქაღალდეების რეინდექსირება

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

ჟურნალში ხედავთ რამდენ ხანს გრძელდება ეს პროცესი, ჩემს შემთხვევაში რამდენიმე ათასი (15 ათასი) ჩანაწერით, დაახლოებით 3-4 წუთი.

რჩება მხოლოდ იმის გარკვევა, თუ როგორ უნდა დააწკაპუნოთ ამ ღილაკზე, მაშინ, როდესაც ეს გვჭირდება.

თურმე კერიო აქვთ საკუთარი API

აღწერა
დოკუმენტაცია

ფუნქცია, რომელიც ასრულებს ჩვენს დავალებას, ასე გამოიყურება −
session = callMethod("Domains.checkPublicFoldersIntegrity",{}, token)

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

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

სკრიპტის იმპლემენტაცია

CMD სკრიპტის მაგალითი და აღწერა

ხელახალი ინდექსი.bat

@echo off
set dir=%~dp0
%dir:~0,2%
CD "%~dp0"
md "%CD%LOG"
md "%CD%Setup"

ECHO -Start- >> "%CD%LOG%Computername%.log"
ECHO Start -> %Computername% %Date% %Time% >> "%CD%LOG%Computername%.log"

SetLocal EnableDelayedExpansion
for /f "UseBackQ Delims=" %%A IN ("%CD%Setup%Computername%.List") do (
  set /a c+=1
  set "m!c!=%%A"
)

set d=%c%
Echo Folder = %c%
ECHO Folder = %c% >> "%CD%LOG%Computername%.log"
ECHO.
ECHO. >> "%CD%LOG%Computername%.log"

:start
cls
if %c% LSS 1 exit
set /a id=1
set R=0

:Find
REM PF-Start
if "%id%" gtr "%c%" if %R% == 1 Goto Reindex 
if "%id%" gtr "%c%" timeout 60 && Goto start

For /F "tokens=1-3" %%a IN ('Dir "!m%id%!#msgs" /-C/S/A:-D') Do Set 2DirSize!id!=!DS!& Set DS=%%c
if "2DirSize!id!" == "" set 1DirSize!id!=!2DirSize%id%!

echo %id%
ECHO !m%id%!
echo Count        [ !1DirSize%id%! -- !2DirSize%id%! ]

if "!1DirSize%id%!" == "!2DirSize%id%!" ECHO Synk

REM DEL index.fld
if "!1DirSize%id%!" NEQ "!2DirSize%id%!" del /f /q !m%id%!index.fld && del /f /q !m%id%!indexlog.fld && del /f /q !m%id%!search.fld && set R=1 && ECHO RE-index Count && ECHO RE-index Count %Date% %Time% - Delete !m%id%! >> "%CD%LOG%Computername%.log"

set 1DirSize!id!=!2DirSize%id%!

ECHO.
ECHO.

set /a id+=1
goto Find

:Reindex
ECHO. >> "%CD%LOG%Computername%.log"
ECHO --- RE-INDEX - Start - %Date% %Time% --- >> "%CD%LOG%Computername%.log"
ECHO. >> ----------------------------------- >> "%CD%LOG%Computername%.log"
call PublicFolders.py
timeout 60
goto start

exit

სკრიპტის ასლი გაშვებულია თითოეულ ფოსტის სერვერზე (შესაძლებელია როგორც სერვისი, ადმინისტრატორის უფლებები არ არის საჭირო)

სკრიპტი კითხულობს ფაილს Setup%Computername%.List

სადაც %Computername% არის მიმდინარე სერვერის სახელი (საქაღალდეში შეიძლება შეიცავდეს ერთდროულად ყველა სერვერის სიას.)

%Computername%.List ფაილი შეიცავს სინქრონიზებული დირექტორიების სრულ ბილიკებს, თითოეული გზა იწერება ახალ ხაზზე, ის არ უნდა შეიცავდეს ცარიელ ხაზებს.

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

სკრიპტის ამოცანაა ყველა ფაილის დათვლა მითითებულ დირექტორიაში.

ყოველი დირექტორიის დათვლის ბოლოს, თუ ფაილების მიმდინარე მნიშვნელობა მინიმუმ ერთ დირექტორიაში არ ემთხვევა წინას, სკრიპტი წაშლის ფაილებს სინქრონიზებული ფოსტის დირექტორიას ძირეული დირექტორიადან: index.fld, indexlog.fld, search.fld და იწყებს ინდექსირების პროცესს - საჯარო ფოსტის საქაღალდეებს.

ინფორმაცია დავალებების შესრულების შესახებ იდება LOG დირექტორიაში.

ინდექსირების პროცესი
ინდექსირების პროცესი მცირდება Kerio API ფუნქციის შესრულებამდე
Session = callMethod("Domains.checkPublicFoldersIntegrity",{}, ჟეტონი)

შესრულების მაგალითი მოცემულია - პითონში
PublicFolders.py

import json
import urllib.request
import http.cookiejar
""" Cookie storage is necessary for session handling """
jar = http.cookiejar.CookieJar()
opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))
urllib.request.install_opener(opener)
""" Hostname or ip address of your Kerio Control instance with protocol, port and credentials """

server = "http://127.0.0.1:4040"
username = "user"
password = "password"

def callMethod(method, params, token = None):
    """
    Remotely calls given method with given params.
    :param: method string with fully qualified method name
    :param: params dict with parameters of remotely called method
    :param: token CSRF token is always required except login method. Use method "Session.login" to obtain this token.
    """
    data =  {"method": method ,"id":1, "jsonrpc":"2.0", "params": params}

    req = urllib.request.Request(url = server + '/admin/api/jsonrpc/')
    req.add_header('Content-Type', 'application/json')
    if (token is not None):
        req.add_header('X-Token', token)    

    httpResponse = urllib.request.urlopen(req, json.dumps(data).encode())

    if (httpResponse.status == 200):
        body = httpResponse.read().decode()
        return json.loads(body)

session = callMethod("Session.login", {"userName":username, "password":password, "application":{"vendor":"Kerio", "name":"Control Api-Local", "version":"Python"}})
token = session["result"]["token"]
print (session)

session = callMethod("Domains.checkPublicFoldersIntegrity",{"domainId": "test2.local"}, token)
print (session)

callMethod("Session.logout",{}, token)

http://127.0.0.1:4040 შეგიძლიათ დატოვოთ ის, როგორც არის, მაგრამ თუ გჭირდებათ HTTPS, python უნდა ენდოს Kerio სერთიფიკატს.

ასევე აუცილებელია ფაილში მიუთითოთ ანგარიში ფოსტის სერვერის ამ ფუნქციის (Admin - საჯარო ფოსტის საქაღალდეების) შესრულების უფლებით.

იმედი მაქვს, რომ ჩემი სტატია სასარგებლო იქნება Kerio Connect-ის ადმინისტრატორებისთვის.

წყარო: www.habr.com