Синхронизация файлов и папок ubuntu

Синхронизация файлов и папок ubuntu

Общий вид команды

Копирование содержимого директории /local/folder/ с локальной машины на удаленный сервер user@server, в директорию /remote/folder/

Важно обратить внимание на последний слэш: если он есть то копируется содержимое папки, иначе — вся директория, вместе с названием.

• —progress — отображение прогрессбара
• —partial — сохранение частей файлов после копирования (см. детали алгоритма работы rsync), ускоряет последующие копирования
• —force — удаление не пустых директорий
• -e ssh — использование ssh для синхронизации, порт указывается так -e «ssh -p22» , настройка подключений по ssh без ввода пароля описана тут
• -a — алиас для группы ключей (-rlptgoD), сохраняет разные атрибуты файлов/директорий при копировании, включает рекурсию
• -v — вывод в консоль подробных действий
• -z — компрессия передаваемых файлов

Другие полезные опции

• -h — удобный вывод размерностей;
• —max-size=’150k’ — синхронизировать только файлы, размер которых меньше 150Kb;
• —bwlimit=100k — ограничить скорость до 100Kb.

Копирование отдельного файла

Синхронизация двух локальных папок с удалением из всего чего нет в

Тоже предназначение, как и у предыдущей команды, только физически ничего не меняется (симуляция процесса)

Показать разницу между двумя каталогами

И то, из-за чего мне понадобился rsync: надо синхронизировать из периодически обновляемого хранилища группу файлов в другую директорию. В rsync есть опция —files-from=list.txt которая синхронизирует только файл из списка в list.txt, разделитель — новая строка.

Несколько других полезных опции rsync

• —exclude=’*.pyc’ — исключить файлы совпадающие с маской *.pyc, regexp не поддерживается
• —exclude-from=’files.txt’ — исключить файлы, которые упомянуты в files.txt, разделить имен — новая строка
• -h — human-readable формат для размера файлов
• -u — если файл в новее чем в , то не заменять
• —existing — обновление только уже существующих файлов, новые не копируются
• —max-size=’7MB’ — не передавать файлы, больше 7 МБайт

Для rsync есть графический интерфейс — Grsync.

Под Ubuntu нужно установить пакет grsync

Синхронизация файлов от root

Если нужно синхронизировать файлы от root‘a то понадобятся кое-какие манипуляции.

Способ 1. На удаленной машине разрешаем rsync от root без пароля

Тут proft это пользователь под которым подключаемся.

На локальной машине добавим ключ —rsync-path

Способ 2. Подключимся с локальной машины на удаленную с сохранением, на некоторое время, прав на sudo

Как установить и настроить Syncthing

Я думаю, что каждый человек который проводит хоть какое-то время за компьютером, хоть раз, но сталкивался с проблемой передачи файлов между разными устройствами, либо подвидом этой ситуации когда необходимо сделать какой-то файл доступным нескольким пользователям на разных устройствах. Ну, а те, чья работа так или иначе связана с компьютерами, сталкиваются с этой проблемой постоянно, особенно если ты работаешь не сам-один за одним компьютером, а например в коллективе и передавать файлы друг-другу нужно постоянно, какие-то файлы нужно расшарить для всех ну и так далее, то они знают об этой проблеме не по наслышке. И понятное дело, что каждый решает эту задачу по своему. Ну, а я хочу поделиться информацией как эту проблему я решил для себя, причём на мой субъективный взгляд, это лучший способ.

И конечно же я знаю про всякие Dropbox, Google Drive, Resilio Sync и, более того, я даже слышал, что в Windows можно настроить общий доступ к файлам и каталогам. Только вот всё это мне не нравятся. Google Drive, например, неплох как личное облачное хранилище, но совсем не справляется когда необходимо наладить взаимодействие между несколькими пользователями, Dropbox справляется вроде бы неплохо и в использовании удобен, вот только бесплатный тариф ограничен двумя гигабайтами пространства и тремя подключенными устройствами, а платить по 10 баксов в месяц за тариф plus, мне не охота. Ну, а про стандартные средства Windows я и упоминать не буду, о них, как известно, либо хорошо либо никак. В общем, в процессе поисков, было найдено, как мне кажется, идеальное решение — это Syncthing. Он бесплатный, прост в настройке, при этом имеет довольно обширные возможности, он безопасен — данные передаются в зашифрованном виде. Работает на любой операционной системе, есть приложение для Android, авторы также обещают сделать приложение для iOS, а ещё он выполняет синхронизацию по схеме P2P, это означает, что для передачи файл разбивается на части, и если какие-то части файла есть на других нодах, то они тоже будет участвовать в передаче.

И чтобы показать его настройку более наглядно мы установим его на Ubuntu и на Windows.

Установка Syncthing на Ubuntu.

Для начала создадим pgp-ключ, добавим нужный репозиторий и установим программу:

После установки запускаем программу (если есть необходимость можно добавить в автозагрузку) и в браузере переходим по адресу http://127.0.0.1:8384, это веб-интерфейс программы. Все основные настройки интуитивно понятный, пройдёмся по ключевым.

Настройка Syncthing

В правом верхнем углу нажимаем «Действий» и в появившемся меню выбираем «Настройки», в появившейся вкладке задаём имя нашего устройства, под которым нас будут видеть другие пользователи, и путь куда мы хотим поместить общие папки.

Во вкладке «Интерфейс» задаём имя пользователя и пароль.

Во вкладке «Подключения» в графе «Адрес протокола синхронизации» будет стоять значение «default», это означает, что будет использоваться адрес tcp://0.0.0.0 и порт 22000, можно оставить без изменения или можно вписать ip нашего компьютера (можно вписывать как частный так и внешний ip). И в этой же вкладке, если нужно, выставляем ограничения по скорости.

Закрываем окно настроек и переходим к созданию общих папок. Для начала можем удалить созданную автоматически программой папку и нажав «Добавить паку» насоздавать нужное количество папок, одновременно настраивая параметры каждой папки по своему желанию и потребностям.

Установка и настройка Syncthing в Windows

Чтобы установить Syncthing в Windows качаем exe-шник здесь: https://github.com/canton7/SyncTrayzor и, естественно устанавливаем, ну или качаем portabe-версию, тогда не устанавливаем. После запуска откроется графический интерфейс программы, который по внешнему виду, да и по настройкам, никак не отличается от того что в Linux, настраиваем всё по аналогии и пришло время подружить наши компьютеры. Для этого нужно на главный компьютер передать ID других компьютеров, и подобавлять их на главном, в самой программе. Для этого в программе на Windows нажимаем Действия — Показать ID, копируем его и уже в Linux нажимаем «Добавить удалённое устройство» и вводим ID, одновременно указывая к каким папкам мы хотим дать доступ. Когда мы сохраним изменения произойдет синхронизация файлов и папок.

Не менее просто можно подключить мобильный телефон. С Play Market качаем приложение Syncthing, синхронизируем с компьютером, для удобства можно использовать QR-код, и расшариваем доступ, например к галереи, и спокойно получаем доступ к своим фоточкам с телефона на компьютере.

А теперь можешь удалить Dropbox или что ты там используешь и наслаждаться использованием Syncthing. И не забывать возвращаться к нам, что бы узнать про другие крутые приложения.

Синхронизация файлов на python с использованием rsync алгоритма

Не так давно разбирался с такой dropbox-подобной задачей: вот у нас есть сервер на Python, который предоставляет некий API для работы с файлами, и есть куча клиентов, которые посредством данного API должны: a). грузить файлы на сервер, b). получать от сервера обновленные (другими клиентами) файлы. Причем клиенты естественно ничего не знают друг о друге, т.е. синхронизация данных идет только через сервер, и поверх самой синхронизации навёрнута определенная бизнес-логика (проверка прав доступа и т.п).

Сам серверный API по загрузке/скачиванию файлов проблем не вызывает, но вот не хотелось бы на каждый чих (т.е. малейшее изменение файла) гонять лишний траффик и грузить мегабайты данных. При этом если речь идет о работе с документами, то размер загружаемых/скачиваемых данных действительно исчисляется мегабайтами и конечно же не так велик, но вот если клиент редактирует видео и чуть ли не ежеминутно грузит обновленный файл на сервер, то одними мегабайтами тут так легко не отделаться. В этом случае на помощь приходит алгоритм rsync-а. Если кто не в курсе, что это за механизм, вот вырезка из википедии:

Это такой алгоритм, разработанный австралийским программистом Эндрю Триджеллом, для эффективной передачи структур (например, файлов) по коммуникационным соединениям в том случае, когда принимающий компьютер уже имеет отличающуюся версию этой структуры.

А вот кратенькое описание алгоритма, взятое с citforum-а. Путь у нас есть машина Beta, на которой содержится файл B, и машина Alpha, на которой содержится файл A (более поздняя версия файла B):

1. Beta разбивает файл B на блоки длиной L (последний блок может быть меньше L байт) и вычисляет две сигнатуры Rb и Sb для каждого блока, после чего пересылает эти сигнатуры к Alpha.
2. Alpha вычисляет сигнатуры Ra для блоков длинной L, для каждого байтового смещения. После чего сравнивает их с Rb.
3. Для блоков, чьи R сигнатуры совпали, Alpha вычисляет Sa и сравнивает с Sb.
4. Если S сигнатуры совпадают, Alpha отсылает уведомление с номером совпавшего блока, в противном случае Alpha пересылает один байт.
5. Beta получает номера совпавших блоков из B или одиночные байты из файла A и на основе этих данных создаёт копию файла A.

А теперь ближе к практике. На сервере будем придерживаться следующей структуры — для каждого загруженного файла будет храниться целочисленный номер его версии. Для примера, пусть для какого-то абстрактного Word-овского документа example.doc последней версией будет версия под номером 2. И путь есть два клиента — C1 и C2. Оба содержат у себя последнюю версию example.doc с номером 2. Клиент C1 решил изменить у себя файл example.doc. На основании исходного (с версией 2) и изменённого (с версией 3) файла клиент создает файл-дельту example_delta2_c1.doc и загружает его на сервер. Таким образом после загрузки и применения дельты example_delta2_c1.doc на сервере файл example.doc модифицируется и его версия возрастает до 3ки. Пусть аналогичным образом клиент C1 ещё раз модифицирует файл example.doc и поднимет версию файла на сервере до 4ки. А теперь клиент С2, который периодически опрашивает сервер на предмет обновлений, узнает, что файл example.doc изменился. Он отправляет посредством API сигнатуру своего локального файла example.doc версии 2 и в ответ скачивает к себе дельту (сформированную прямо на лету на сервере в рамках запроса) и у себя локально обновляет example.doc до последней 4ой версии. В рамках вышеприведенного примера предполагается, что и клиенты и сервер, при формировании сигнатуры и файлов-дельт используют одну длину разбиения файла на блоки.
Ну а теперь рассмотрим варианты, как можно все вышеперечисленные действия (создание сигнатур, дельт и т.п.) организовать в рамках нашей серверной бизнес логики на Python.

Первый и самый простой вариант — использовать консольную утилиту rdiff, которая по-моему, по умолчанию входит в состав практически всех дистрибутивов linux. Создание сигнатуры исходного файла делается следующим образом:

Создания дельты для получения результирующего файла:

И, наконец, получение результирующего из исходного с применением дельты:

В принципе, данный способ не зависит от того, какой скриптовый язык используется на сервере. Конкретно в Python эти вызовы осуществляются через subprocess.call, а в PHP, например, через shell_exec. Минусы данного решения — лишняя зависимость от командной оболочки операционной системы и от сторонней утилиты. Лично мое мнение — обращаться к функциям типа subprocess.call стоит только в том случае, когда нативными средствами языка решить задачи в принципе невозможно (ну либо же очень затруднительно).

Второй способ — использовать реализацию алгоритма rsync, написанную непосредственно на самом Python-е. Как это выглядит — можно посмотреть вот по этой ссылке либо же взять с pypi какую-либо другую реализацию. С одной стороны — довольно просто и компактно, с другой стороны — такая реализация не должна отличаться высокой производительностью, плюс ко всему, например, в самом первом приведенном примере delta-структура представлена обычным python-овским list-ом, и перед её сохранением в файл нужно предварительно использовать сериализацию (например, pickle).

Третий способ — воспользоваться функционалом утилиты резервного инкрементального копирования rdiff-backup, которая, к слову, написана на Python, по умолчанию входит в состав базовых репозиториев для всех дистрибутивов linux, может быть собрана вручную из открытых исходников (ибо open source), а так же для особых извращенцев гурманов имеется windows-версия утилиты. В плане реализации алгоритма rsync есть ещё одна важная киллер-фича — утилита rdiff-backup предоставляет высокоуровневый интерфейс, т.е. грубо говоря python wrapper, для вызова низкоуровневых функций модуля _librsync, который написан на C (привет производительность!). В плане установки — ставится утилита довольно просто. На дистрибутиве Ubuntu это выглядит как-то так (естественно от root-а или из-под sudo):

На CentOS-е тоже не особо-то сложно:

Либо же можно установить через pip (самый true pythonic way):

Только в последнем случае нужно быть уверенным, что в системе установлена библиотека librsync, иначе rdiff-backup просто не соберётся. Cам функционал для создания дельт и восстановлениия по ним новых версий файлов выглядит так:

Думаю, по коду все и так все понятно без особых комментариев. Из трех предложенных вариантов, на мой взгляд, третий — самый оптимальный способ.

Синхронизация папок с помощью bash и rsync

Bash скрипт, позволяющий делать простую одностороннюю синхронизацию папок. Можно использовать для бэкапа файлов на съёмный носитель и вообще для синхронизации любых папок на компьютере.

Производить синхронизацию будем с помощью rsync.

Собственно, вот весь скрипт:

Что оно делает

Скрипт в бесконечном цикле выполняет синхронизацию двух папок и имеет следующий синтаксис:

Изменения папки /source/dir/ применяются к папке /destination/dir/dir — переименование файлов, удаление, перемещение и т.п.

Как это работает

Разберём весь скрипт по порядку.

Прежде всего нас интересуют вот эти строчки:

В первой строке мы указываем путь к интерпретатору. Это стандартное начало для bash скриптов.

В следующих двух строчках вводим переменные syncfrom и syncto. Это будут наши параметры, которые мы будем указывать уже при запуске скрипта.

syncfrom будет содержать путь к исходной папке, а syncto путь к папке, в которую будет производиться копирование.

Присваиваем им соотвестственно $1 и $2, что означает, что следующая команда запишет путь /source/dir/ в значение переменной syncfrom и путь /destination/dir/ в значение syncto:

Цифры 1 и 2 означают порядковый номер параметра. Если бы я указал 0, то это было бы название скрипта.

Самое интересное в скрипте это строка с вызовом rsync. Она заключена в бесконечный цикл, чтобы постоянно мониторить нашу исходную папку и при необходимости производить синхронизацию.

Здесь параметр -aP означает, что rsync будет действовать рекурсивно и выводить лог синхронизации в терминал.

—delete разрешает удаление, если файлы/папки были удалены из исходной папки. Если вам это не нужно, просто не указывайте этот параметр.

$syncfrom и $syncto это, как уже выше было сказано, пути к папкам.

Если вам надо, чтобы какие-то файлы не попадали в синхронизацию, можно настроить исключения. Делается это следующим образом — нужно указать параметры —exclude:

В этом примере исключаются файлы desktop.ini и все файлы с расширением .tmp.

В том же цикле, что и rsync вызывается команда sleep со значением 2. Это пауза в две секунды. Она тут ради экономии ресурсов компьютера, чтобы не проводить синхронизацию много тысяч раз в секунду. Раз в две секунды для наших целей вполне достаточно.

Если файл не успеет скопироваться за две секунды, то его копирование будет продолжено на следующей итерации и в итоге он будет записан целиком.

Так как в параметрах к rsync есть параметр —delete у нас появляется потенциальная угроза потерять данные в случае банальной опечатки или указания пустой директории как исходной.

Для того, чтобы синхронизация не началась с пустой или несуществующей папкой нужно написать обработчики. За это отвечают строки:

Строка c if проверяет существует ли указанная исходная папка и возвращает сообщение об ошибке, если результат ложь.

elif проверяет не пустая ли папка и сообщает, если это так.

Если оба условия выполнились, то синхронизация начинается.

! Важно. Так как проверка условий происходит до запуска цикла, то синхронизация продолжится если файлы будут удалены после запуска скрипта. Т.е. в сценарии, когда папка оказалась пустой, с уже выполняющейся синхронизацией, это приведёт к удалению файлов в папке назначения.

Как использовать

Положите файл sync.sh в любое удобное место и дайте ему права на выполнение:

Далее выполните скрипт с указанием параметров:

где /source/dir/ это путь к исходной папке, а /destination/dir/ путь к папке назначения.

Rsync

Rsync — это инструмент для Linux, который можно использовать для синхронизации файлов между удаленными и локальными серверами. Rsync имеет много опций, которые могут помочь вам определить соединения, которые вы делаете. От выбора типа оболочки, которая должна использоваться для файлов, которые должны быть исключены при передаче, rsync дает вам возможность формировать спецификации передачи.

Однако следует отметить, что rsync позволяет очень легко случайно перезаписать ваши файлы. Поэтому мы рекомендуем перепроверить все перед синхронизацией или с помощью параметра –dry-run.

ТИПИЧНЫЙ ФОРМАТ

Типичный формат rsync не очень пугающий

ПАРАМЕТРЫ

Вот список основных опций rsync для начала работы.

НЮАНСЫ RSYNC

Rsync не лишен своих нюансов. Вот некоторые вещи, которые следует помнить при использовании rsync.

ОБЪЕДИНЕНИЕ ПАРАМЕТРОВ В КОМАНДАХ

Если используется несколько опций с дефисом (-), они могут быть объединены в один набор опций, который имеет только один дефис. Например, -avh будет вызывать опции -a , -v и -h.