Как загрузить большой файл на гитхаб

Обновлено: 15.01.2025

у меня есть два сервера, производство и разработка. На рабочем сервере есть два приложения и несколько (6) баз данных (MySQL), которые мне нужно распространить разработчикам для тестирования. Все исходные коды хранятся в GitLab на сервере разработки и разработчики работают только с этим сервером и не имеют доступа к рабочему серверу. Когда мы выпускаем приложение, master входит в систему и вытаскивает новую версию из Git. Этот базы данных большие (более 500 м каждая и подсчет), и мне нужно распространять их как можно проще разработчикам для тестирования.

возможные решения

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

этот был найден не рабочий.

Cron на рабочем сервере сохраняет двоичные журналы каждый день и помещает их в ветвь этой базы данных. Итак, в ветке есть файлы с ежедневными изменениями, и разработчик вытаскивает файлы, которых у него нет. Текущий дамп SQL будет отправлен разработчику другим способом. И когда размер репозитория станет слишком большим, мы отправим полный дамп разработчикам и очистим все данные в репозитории и начнем с начало.

вопросы

возможно ли решение?
если git нажимает/тянет в / из репозитория, загружает / загружает целые файлы или просто изменяет их (т. е. добавляет новые строки или редактирует текущие)?
~~может ли Git управлять такими большими файлами?~~ нет.
~~Как установить, сколько ревизий сохраняется в репозитории?~~ не имеет значения с новым решение.
есть ли лучшее решение? Я не хочу заставлять разработчиков загружать такие большие файлы через FTP или что-то подобное.

rsync может быть хорошим вариантом для эффективного обновления разработчиками копий баз данных.

он использует Дельта-алгоритм для постепенного обновления файлов. Таким образом, он передает только файлы, которые были изменены или которые являются новыми. Конечно, им все равно нужно сначала загрузить полный файл, но более поздние обновления будут быстрее.

по существу вы получаете аналогичное инкрементное обновление как git fetch без постоянно расширяющегося начального копия, которую даст клон git. Потеря не имеет истории, но звучит так, как будто вам это не нужно.

чтобы передать базы данных разработчику, вы можете использовать команду, подобную:

или разработчики могут вытащить базы данных, которые им нужны:

Microsoft вносит свой вклад в Microsoft / GVFS: виртуальная файловая система Git, которая позволяет git обрабатывать"крупнейшее РЕПО на планете"
(т. е.: база кода Windows, которая составляет примерно 3,5 м файлов и, при регистрации в репозитории Git, приводит к РЕПО около 300 ГБ и производит 1,760 ежедневных "лабораторных сборок" через 440 филиалов в дополнение к тысячам проверки запроса на вытягивание строит)

GVFS виртуализирует файловую систему под вашим репозиторием git, чтобы git и все инструменты видели то, что кажется обычным РЕПО, но GVFS загружает только объекты по мере необходимости.

некоторые части GVFS могут быть переданы вверх по течению (для самого Git).
А пока . --39-->все новые разработки Windows теперь (август 2017) на Git.

на дизайн bup выделяет три проблемы, которые ограничивают РЕПО git:

большие файлы (the xdelta для packfile находится только в памяти, что не хорошо с большими файлы)
огромное количество файлов, что означает, один файл на blob и медленный git gc для создания одного файла пакета за раз.
огромный packfiles, с индексом packfile неэффективным для извлечения данных из (огромного) packfile.

обработка огромных файлов и xdelta

основная причина, по которой git не может обрабатывать огромные файлы, заключается в том, что он запускает их через xdelta , что означает он пытается загрузить все содержимое файла в память сразу.
если бы он этого не сделал, ему пришлось бы хранить все содержимое каждой отдельной ревизии каждого отдельного файла, даже если вы изменили только несколько байтов этого файла.
Это было бы ужасно неэффективное использование дискового пространства, и git хорошо известен своим удивительно эффективным форматом репозитория.

к сожалению, xdelta отлично подходит для небольших файлов и становится удивительно медленным и голодным памяти для больших файлов.
Для основной цели git, т. е. управление исходным кодом, это не проблема.

то, что bup делает вместо xdelta, мы называем" hashsplitting ."
Мы хотели универсальный способ эффективного резервного копирования любой большой файл, который может меняться небольшими способами, без сохранения всего файла каждый время. Мы читаем файл по одному байту за раз, вычисляя скользящую контрольную сумму последних 128 байты.

rollsum кажется, довольно хорошо справляется со своей работой. вы можете найти его в bupsplit.c .
В принципе, он преобразует последние 128 байт в 32-разрядное целое число. Затем мы берем самые низкие 13 бит rollsum, и если они все 1, мы считаем, что это конец куска.
Это происходит в среднем один раз 2^13 = 8192 bytes , так что средний размер блока 8192 байт.
Мы разделяем эти файлы на куски на основе скользящей контрольной суммы.
Затем мы храним каждый кусок отдельно (индексированный его sha1sum) как Git blob.

С hashsplitting, независимо от того, сколько данных вы добавляете, изменяете или удаляете в середине файла, все куски до и после пораженный кусок абсолютно одинаковые.
Все, что имеет значение для hashsplitting алгоритм-это 32-байтовая последовательность "разделитель", и одно изменение может повлиять только на одну последовательность разделителей или байты между двумя последовательностями разделителей.
Как по волшебству, алгоритм hashsplit chunking будет каждый раз кусать ваш файл одинаково, даже не зная, как он его ранее.

следующая проблема менее очевидна: после того, как вы сохраните серию кусков как Git blobs, как вы сохраняете их последовательность? Каждый blob имеет 20-байтовый sha1 идентификатор, что означает, что простой список объектов будет 20/8192 = 0.25% длина файла.
Для файла 200GB это 488 мегабайт только данных последовательности.

мы расширяем алгоритм hashsplit немного дальше, используя то, что мы называем "fanout."Вместо того, чтобы проверять только последние 13 бит контрольной суммы, мы используем дополнительные биты контрольной суммы для получения дополнительных расщеплений.
То, что вы в конечном итоге, является фактическим деревом капель - какие объекты git 'tree' идеально подходят для представлять собой.

обработка огромного количества файлов и git gc

обработка огромного репозитория (что означает огромное количество огромных packfiles)

вы действительно, действительно, действительно не хочу большие двоичные файлы в репозитории Git.

каждое добавляемое вами обновление будет в совокупности добавлять к общему размеру вашего репозитория, что означает, что в будущем ваше git-РЕПО будет занимать все больше и больше времени для клонирования и использования все большего и большего дискового пространства, потому что Git хранит всю историю филиала локально, что означает, что когда кто-то проверяет филиал, им не просто нужно загрузить последнюю версию базы данных; им также придется загрузить все предыдущие версии.

вы можете посмотреть на решение, как git-annex, что касается управления (большими) файлами с git, без проверки содержимого файла в git (!)
(Февраль 2015 года: сервис хостинг, как GitLab интегрирует его изначально:
См."поддерживает ли GitLab большие файлы через git-annex или иначе?")

git не управляет большими файлами, как объясняется Янтарь на ответ.

что это не значит, что git не сможет сделать лучше в один прекрасный день.
От эпизод GitMinutes 9 (май 2013, см. Также ниже) С Peff (Джефф Кинг), в 36'10":

есть все другие области больших репозиториев, где люди заинтересованы в хранении, вы знаете, 20 или 30 или 40 ГБ, иногда даже репозиториев размером с ТБ, и да, это происходит от наличия большого количества файлов, но многое из этого происходит от имея действительно большие файлы и действительно большие двоичные файлы, которые не так хорошо справляются друг с другом.

это своего рода открытая проблема. Есть несколько решений: git-annex, вероятно, самый зрелый из тех, где они в основном не помещают актив в git, они помещают большой актив на сервер активов и ставят указатель в git.

Я хотел бы сделать что-то подобное, где актив принципиально в git, то есть SHA1 этого объекта является частью SHA1, которая входит в дерево, которая входит в идентификатор фиксации и все эти вещи.
Таким образом, с точки зрения git, он является частью репозитория, но на уровне ниже, на уровне хранения объектов, на уровне ниже концептуальная график истории, где у нас уже есть несколько способов хранения объекта: у нас есть свободные объекты, мы упакованные объекты, Я хотел бы иметь, возможно, новый способ хранения объекта, который это сказать: "у нас его нет, но он доступен сервером активов" или что-то в этом роде.

(Томас Феррис Николайсен) О, круто.

проблема с такими вещами, как git-annex : Как только вы используете их, вы. навсегда запертый в решениях, которые ты принял в то время. Вы знаете, что если вы решите, что oh 200 MB большой, и мы будем хранить на сервере активов, а затем, позже вы решите, aah это должно было быть 300 МБ, ну, не повезло: это закодировано в вашей истории навсегда.
И так сказать принципиально, на уровне git этот объект на репозиторий git, а не какой-то указатель на него, а не какой-то указатель на сервер активов,фактический объект есть, а затем заботиться о тех деталях на низком уровне, на уровне хранения, то это освобождает вас, чтобы сделать много различных решений, и даже изменить ваше решение позже о том, как вы действительно хотите сохранить материал на диске.

не первоочередной проект.

Christian Couder (CD): цель состоит в том, чтобы git refs хранились в базе данных, например? Майкл Хаггерти (MH): Да, я вижу это как два интересных аспекта: первый-это просто возможность подключать разные ссылки на исходные данные. Запись ссылки хранятся в файловой системе, как сочетание свободных ссылок и упакованные ссылок.
Свободная ссылка-это один файл на ссылку, а упакованная ссылка-один большой файл, содержащий список многих ссылок.

Так что это хорошая система, особенно для локального использования; поскольку у нее нет реальной проблемы с производительностью для нормальных людей, но у нее есть некоторые проблемы, например, вы не можете хранить рефлоги ссылок после удаления ссылок, потому что могут быть конфликты с новыми ссылками, которые были созданы с похожими именами. Существует также проблема, когда ссылочные имена хранятся в файловой системе, поэтому вы можете иметь ссылки, которые называются похожими, но с разной капитализацией.
Таким образом, это вещи, которые могут быть исправлены, имея другую справочную систему в целом.
И другой аспект серии патчей Дэвида Тернера-это изменение для хранения ссылок в базе данных под названием lmdb, это очень быстрая база данных на основе памяти, которая имеет некоторые преимущества в производительности по сравнению с фоновым файлом.

[следует за другими соображениями вокруг иметь более быструю упаковку, и рекламу заплаты ссылки]

так каждый файл aux получает базовое имя, дату и SHA(для некоторой версии n) sum.
если у вас есть дикий оборот файлов, использование только SHA представляет собой крошечную, но реальную угрозу хэш-столкновения, следовательно, включение даты (время эпохи или дата ISO).
поместите полученное имя файла в код, так что AUX chunk включен, очень конкретно, по ссылке.
структурируйте имена таким образом, чтобы небольшой скрипт можно было легко записать в Git grep все имена файлов aux, чтобы список для любой фиксации тривиален для получения. Это также позволяет старым удаляться в какой-то момент и может быть интегрирована с системой развертывания, чтобы вытащить новые файлы aux на производство без clobbering старых (пока), до активации кода из репозитория git.

Втискивание огромных файлов в git (или большинство репозиториев) оказывает неприятное влияние на производительность git через некоторое время - a git clone действительно не должно занять двадцать минут, например. В то время как использование файлы по ссылке означает, что некоторым разработчикам никогда не придется загружать большие куски вообще (резкий контраст с git clone ), поскольку большинство из них имеют отношение только к развернутому коду в производстве. Конечно, ваш пробег может отличаться.

загрузка больших файлов иногда создает проблемы и ошибки. Обычно такое случается. В основном git поддерживает менее 50 МБ файла для загрузки. Для загрузки более 50 МБ файлов в репозиторий Git пользователю необходимо установить другой помощник, который сотрудничает для загрузки большого файла(.mp4,.mp3,.psd) и т.д.

есть несколько основных команд git, которые вы знаете перед загрузкой большого файла в git. это конфигурация для загрузки на GitHub. он должен установить gitlfs.exe

тогда вы должны использовать основные команды git вместе с некоторыми другими

Я использую модуль GoogleMaps размером 130 МБ, поэтому github не позволит мне загрузить мой проект. Как это можно обойти?

Я предлагаю исключить каталог Pods (добавив его в ваш файл .gitignore) в репозиторий git. Поды можно воссоздать с помощью вашего подфайла, поэтому вам не нужно хранить их в своем репозитории.

Перенести весь каталог на GitHub кажется неправильным. Просмотрите документацию или ознакомьтесь с такими примерами, как эта привязка GoogleDirections, которая включает необходимый json.

Для страницы квот диска Github существует только строгое ограничение. размером 100 МБ на отдельные файлы . Также существует рекомендуемый лимит репозитория в 1 ГБ.

Совет: если вы регулярно отправляете большие файлы на GitHub, рассмотрите возможность внедрения Git Large File Storage (Git LFS) как части вашего рабочего процесса. Git LFS хорошо работает с GitHub Flow и может использоваться с любым большим файлом, независимо от его тип. Для получения дополнительной информации см. «Управление версиями больших файлов».

Однако в этом случае действительно похоже, что вам следует создать подмодуль / a> или полностью использовать .gitignore для удаления фреймворка из репозитория.

Если зависимость SDK Google Maps делает ваш проект очень большим, лучше добавить его в свой .gitignore , чем хранить копию всего этого, независимо от того, использует ли он LFS или что-то еще. механизм.

Поскольку ваш проект использует Swift, когда Xcode поддерживает Swift Package Manager (SPM), вы сможете указать Maps SDK как зависимость в вашем Package.swift на основе тега или ветви. А затем swift build (или эквивалент в Xcode) будет управлять клонированием зависимостей, обновлениями и сборками зависимостей этого типа проекта.

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

если вы не видите жесткого предела, вы должны будете рассмотреть основную рекомендацию «быть разумным».

Для лучшей производительности мы рекомендуем хранить хранилища объемом менее 1 ГБ каждый. Этот предел легко соблюдается, если большие файлы (обычно двоичные файлы) хранятся вне хранилища. Если размер вашего хранилища превышает 1 ГБ, вы можете получить от службы поддержки вежливое электронное письмо с просьбой уменьшить размер хранилища, чтобы уменьшить его размер до 1 ГБ.

Верно ли мое понимание того, что это лимит на репо? Например, я могу иметь 2 репозитория по 0,5 ГБ? Повлияет ли один файл .99 ГБ на эту производительность или 99 .1 ГБ файлов?

Пределы хранения GitHub на сентябрь 2015

1 ГБ (рекомендуется)

Файл бинарного выпуска для репозитория : 2 ГБ (строго)

Поддержка больших файлов GitHub (размер файла> 100 МБ)

GitHub поддерживает большое файловое хранилище для всех репозиториев Git с Git LFS - новым расширением Git с открытым исходным кодом.

Схема разработки, изначально называемой GitHub Asset Management System, большой системой управления файловыми активами для GitHub:

22 сентября 2013 - предан GitHub.
8 апреля 2015 - Поддержка больших файлов для GitHub было объявлена и ранний доступ предоставляется.
01 октября 2015 - git-lfs выпущен для всех учетных записей , большие файлы поддерживаются бесплатно до 1 ГБ на учетную запись и ежемесячная квота пропускной способности составляет 1 ГБ. Более высокие квоты доступны для покупки .

Ограничения пропускной способности GitHub

Ограничение пропускной способности Git-файлов репозитория: незначительно больше, чем у среднего пользователя GitHub

Если ваше использование полосы пропускания значительно превышает среднее использование полосы пропускания (определяемое исключительно GitHub) другими пользователями GitHub, мы оставляем за собой право немедленно отключить вашу учетную запись или ограничить ваш файловый хостинг до тех пор, пока вы не сможете уменьшить потребление пропускной способности.

Условия использования GitHub, раздел G, пункт 12

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

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

Какие типы файлов следует хранить в Git?

Исходный код — не зависимости

По мере того как ваша команда работает с редакторами и инструментами для создания и обновления файлов, следует разместить эти файлы в Git, чтобы ваша команда могла использовать преимущества рабочего процесса Git. Не зафиксируйте другие типы файлов, например библиотеки DLL, файлы библиотек и другие зависимости, которые не создаются командой, но код зависит от вашего репозитория. Доставьте эти файлы через Управление пакетами в свои системы.

Управление пакетами объединяет зависимости и устанавливает файлы в систему при развертывании пакета. Версии пакетов позволяют убедиться, что код, протестированный в одной среде, работает в другой среде в том случае, если они имеют одинаковые установленные пакеты.

Не фиксировать выходные данные

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

Хранение небольших, нечасто обновляемых двоичных источников в Git

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

Даже небольшие двоичные файлы могут вызвать проблемы при частом обновлении. 100. изменения в двоичном файле 100 КБ приведут к тому же объему хранилища, что и 10 изменений в 1 МБ, и из-за частоты обновления меньшего двоичного файла снижается производительность ветвления чаще, чем в большом двоичном файле.

Не зафиксируйте большие, часто обновляемые двоичные ресурсы

Git будет управлять одной основной версией файла, а затем сохранять только отличия этой версии в процессе, известном как делтификатион. Делтификатион и сжатие файлов позволяют Git сохранять весь журнал кода в локальном репозитории. Большие двоичные файлы, как правило, полностью меняются между версиями и, как правило, уже сжаты, что затрудняет управление этими файлами, поскольку разница между версиями очень велика. Git должен хранить все содержимое каждой версии файла и испытывать трудности с сохранением пространства с помощью делтификатион и сжатия. Хранение полных версий этих файлов приводит к увеличению размера репозитория с течением времени, снижая производительность ветвления, увеличивая время клонирования и расширяя требования к хранению.

Стратегии работы с большими двоичными файлами с исходным кодом

Не зафиксируйте сжатые архивы данных. Лучше распаковать файлы и зафиксировать источники, которые могут быть различны, позволяя службе Git сжимать данные в репозитории.
Избегайте фиксации скомпилированного кода и других двоичных зависимостей. Зафиксируйте источник и создайте зависимости или используйте решение по управлению пакетами для версии и предоставьте эти файлы в систему.
Хранение конфигурации и других структурированных данных в форматах с открытым текстом в формате простого текста, таких как JSON.

использование служба хранилища больших файлов Git (LFS)

При наличии исходных файлов с большими различиями между версиями и частыми обновлениями можно использовать Git LFS для управления этими типами файлов. Git LFS — это расширение Git, которое фиксирует данные, описывающие большие файлы, в фиксации в репозитории и сохраняет содержимое двоичного файла в отдельном удаленном хранилище. При клонировании и переключении ветвей в репозитории Git LFS скачивает правильную версию из этого удаленного хранилища. Локальные средства разработки прозрачно будут работать с файлами, как если бы они были зафиксированы непосредственно в репозитории.

Преимущества

Преимущество Git LFS заключается в том, что ваша команда может использовать знакомый комплексный рабочий процесс Git независимо от того, какие файлы создает ваша команда. Файлы LFS могут быть достаточно большими. Кроме того, начиная с версии 2,0, Git LFS поддерживает блокировку файлов , чтобы помочь вашей команде работать с большими, непохожими ресурсами, такими как видео, звуки и карты игр.

LFS Git полностью поддерживается и предоставляется бесплатно в Azure DevOps Services. чтобы использовать LFS с Visual Studio, требуется по крайней мере Visual Studio 2015 с обновлением 2. Просто следуйте инструкциям по установке клиента, настройке отслеживания LFS для файлов в локальном репозитории и последующей отправке изменений в Azure Repos.

Ограничения

В Git LFS есть некоторые недостатки, которые следует учесть перед внедрением:

Каждый клиент Git, используемый вашей командой, должен установить клиент Git LFS и понять его конфигурацию отслеживания.
Если клиент LFS Git не установлен и не настроен должным образом, двоичные файлы, зафиксированные с помощью Git LFS, не будут отображаться при клонировании репозитория. Git загрузит данные, описывающие большой файл (в котором LFS Git фиксируется в репозитории), а не сам двоичный файл. При фиксации больших двоичных файлов без установленного клиента Git LFS отправляет двоичный файл в репозиторий.
Git не может объединить изменения из двух разных версий двоичного файла, даже если обе версии имеют общий родительский объект. Если два человека одновременно работают над одним и тем же файлом, они должны работать вместе, чтобы согласовать их изменения, чтобы избежать перезаписи других работ. Git LFS обеспечивает блокировку файлов для помощи. Пользователи по-прежнему должны всегда получать последнюю копию двоичного ресурса перед началом работы.
Azure Repos в настоящее время не поддерживает использование SSH в репозиториев с отслеживанием файлов LFS Git.
Если пользователь перетаскивает и удаляет двоичный файл через веб-интерфейс в репозиторий, настроенный для LFS Git, двоичный объект будет зафиксирован в репозитории, а не в указателях, которые будут зафиксированы через клиент Git LFS.
Максимальный размер файла составляет 50 ГБ.
Ограничение по времени для отправки одного файла составляет 1 час.

Формат файла

Файл, записанный в репозиторий для файла с отслеживанием Git LFS, будет содержать несколько строк с парой "ключ — значение" в каждой строке:

URL-адрес GitHub, включенный в значение version, определяет только тип файла указателя LFS и не является ссылкой на двоичный файл.

Известные проблемы

если вы используете версию LFS ниже 2.4.0 с Azure DevOps Server или TFS, то для проверки подлинности с использованием NTLM вместо Kerberosтребуется дополнительный шаг настройки. Этот шаг больше не требуется для LFS 2.4.0, и мы настоятельно рекомендуем выполнить обновление.

Читайте также: