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

Обновлено: 02.07.2024

Если вы еще не слышали об этом, Google Colab Является ли платформа, которая широко используется для тестирования прототипов ML на его Бесплатный K80 GPU Отказ Если вы слышали об этом, шансы, что вы дали ему выстрел. Но вы могли бы раздражать из-за сложности, участвующей в передаче больших наборов данных.

Этот блог компилирует некоторые методы, которые я нашел полезным для Загрузка и Загрузка Большие файлы из вашей локальной системы до Google Colab Отказ Я также включил дополнительные методы, которые могут полезны для передачи Меньшие файлы с меньшими усилиями. Некоторые из методов могут быть распространены на другие Услуги удаленного ноутбука Jupyter, как градиент Paperspace.

Передача больших файлов

1. Dropbox.

Dropbox предлагает до 2 ГБ свободного места для хранения на счет. Это устанавливает верхний предел на сумму данных, которые вы можете передавать в любой момент. Передача через Dropbox относительно легче Отказ Вы также можете выполнить те же шаги для Другие ноутбуки , например Градиент Paperspace Отказ

Шаг 1: Архив и загрузка

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

Одним из возможных методов архивирования является преобразование папки, содержащей ваш набор данных в файл «.tar». Ниже приведен фрагмент кода показывает, как преобразовать папку с именем «DataSet» в домашнем каталоге в файл «DataSet.Tar», с вашего терминала Linux.

В качестве альтернативы, вы можете использовать WinRar или 7Zip, что бы вам удобнее для вас. Загрузите архивированный набор данных в Dropbox.

Шаг 2: клонировать репозиторий

Откройте Google Colab и начните новый ноутбук.

Клон это Github Repository Отказ Я изменил Оригинал Код, чтобы он мог добавить токен доступа Dropbox из ноутбука. Выполнить следующие команды один за один Отказ

Шаг 3: Создайте токен доступа

Выполните следующую команду, чтобы увидеть первоначальные инструкции по настройке.

Он будет отображать инструкции о том, как получить токен доступа и попросить вас выполнить следующую команду. Замените смелые буквы с вашим токеном доступа, затем выполните:

Выполнить Bash Dropbox_uploader.sh Опять же, чтобы связать свою учетную запись Dropbox в Google Colab. Теперь вы можете загрузить и загружать файлы из ноутбука.

Шаг 4: Передача содержимого

Загрузить в Dropbox из Colab:

2. Google Drive.

Google Drive предлагает до 15 ГБ бесплатное хранение для каждой учетной записи Google. Это устанавливает верхний предел на сумму данных, которые вы можете передавать в любой момент. Вы всегда можете расширить этот предел на большие суммы. Colab упрощает процесс аутентификации для Google Drive.

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

Шаг 1: Архив и загрузка

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

И снова вы можете использовать WinRAR или 7ZIP, если вы предпочитаете. Загрузите в архивированный набор данных в Google Drive.

Шаг 2: Установка зависимостей

Откройте Google Colab и начните новый ноутбук. Установите Pydrive, используя следующую команду:

Импортируйте необходимые библиотеки и методы (Imports Bold требуется только для Colab Google. Не импортируйте их, если вы не используете Colab).

Шаг 3: Авторизуйте Google SDK

Для Google Colab:

Теперь вы должны авторизовать Google SDK для доступа к диску Google из Colab. Во-первых, выполните следующие команды:

Вы получите подсказку, как показано ниже. Следуйте по ссылке, чтобы получить ключ. Скопируйте и вставьте его в поле ввода и нажмите Enter.

Для других служб ноутбуков Jupyter (Ex: градиент Paperspace):

Перейти к API-консоль и сделать свой собственный проект. Затем найдите «API Google Drive API», выберите запись и нажмите «Включить». Выберите «учетные данные» из левого меню, нажмите «Создать учетные данные», выберите «ID Client Oauth». Вы должны увидеть меню, такое как изображение, показанное ниже:

Установите «Тип приложения» на «Другое». Дайте соответствующее имя и нажмите «Сохранить».

Загрузите идентификатор клиента OAUTH 2.0, который вы только что создали. Переименовать Это до client_secrets.json.

Загрузите этот файл JSON в свою ноутбук. Вы можете сделать это, нажав кнопку «Загрузить» с домашней страницы ноутбука (показано ниже). (Примечание. Не используйте эту кнопку, чтобы загрузить ваш набор набора данных, так как это будет чрезвычайно трудоемкость.)

Теперь выполните следующие команды:

Остальная часть процедуры это Похожие к тому из Google Colab.

Шаг 4: Получите идентификатор вашего файла

Включите совместное использование ссылок для файла, который вы хотите перенести. Скопируйте ссылку. Вы можете получить такую ссылку, как это:

Скопируйте только смелую часть вышеуказанной ссылки.

Шаг 5: Передача содержимого

Выполнить следующие команды. Здесь Your_file_id получается на предыдущем шаге, а Download.tar это имя (или путь), которое вы хотите сохранить файл как.

Загрузить в Google Drive из Colab:

Выполнить следующие команды. Здесь File_on_colab.txt это имя (или путь) файла на Colab, а Drive.txt это имя (или путь), которое вы хотите сохранить файл как (на диске Google).

Передача меньших файлов

1. Модуль файлов Google Colab

У Google Colab есть встроенный Модуль файлов С помощью которого вы можете загружать или загружать файлы. Вы можете импортировать его, выполнив следующее:

Используйте следующую команду для загрузки файлов в Google Colab:

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

Используйте следующую команду для загрузки файла из Google Colab:

Эта функция работает лучше всего в Google Chrome Отказ По моему опыту он работал только один раз на Firefox, из-за 10 попыток.

2. Github

Это «Hack-Ish» способ передачи файлов. Вы можете создать репозиторий GitHub с небольшими файлами, которые вы хотите перенести.

Как только вы создаете репозиторий, вы можете просто клонировать его в Google Colab. Затем вы можете протолкнуть изменения в удаленный репозиторий и потяните обновления на вашу локальную систему.

Но отметим, что GitHub имеет жесткий предел 25 МБ на файл, а мягкий предел 1 ГБ за репозиторий.

Загрузка больших файлов размером более 100 МБ на Github

Обычно после фиксации, когда мы нажимаем на Github, размер одного файла не превышает 100 МБ, поэтому такая ситуация практически не встречается.
Однако вы всегда будете сталкиваться, когда размер одного файла превышает 100 МБ, при нажатии появляется следующая ошибка:

Установите git-lfs на этот компьютер
Здесь нет никаких сложностей, просто установите согласно официальному сайту.

После этого порядок отправки больших файлов, следующий порядок официального сайта:

Установите расширение командной строки Git. Вам нужно только один раз настроить Git LFS.
В каталоге проекта выполните следующую команду:

Выберите типы файлов, которыми Git LFS будет управлять (или напрямую отредактируйте .gitattributes). Вы можете настроить другие расширения файлов в любое время. После успешного выполнения этого шага будет создан файл gitattributes.

git lfs track "* .a" - здесь "* .a" - это путь к большому файлу, который вы хотите загрузить

Затем добавьте большие файлы в локальный кеш

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

Нима, новички всегда мочеиспускают. .

Как показано ниже:

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

Первый и второй шаги такие же, как и выше. На третьем шаге сначала зафиксируйте файл .gitattributes отдельно, затем нажмите и после завершения перейдите к четвертой части (выполните после четвертой части добавьте git lfs ls-files Вы должны уметь видеть вещи).
Здесь не должно быть проблем.

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, и мы настоятельно рекомендуем выполнить обновление.

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

Для лучшей производительности мы рекомендуем хранить хранилища объемом менее 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

у меня есть два сервера, производство и разработка. На рабочем сервере есть два приложения и несколько (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 вместе с некоторыми другими

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