Ставим VirtualBox

Знакомство с linux начнем с установки системы, так как установить на реальную машину мы по понятным причинам на компьютеры в кабинетах не можем, будем ставить в вируталку. Для этого будем использовать virtualbox, хотя есть и альтернативные решения.

На компах в классах программа как правило уже стоит. Нам важно только, чтобы версия была где-нибудь не ниже 6.1.22. Если вы хотите попробовать дома, то надо установить себе virtualbox отсюда https://www.virtualbox.org/wiki/Downloads

Качаем Sparky Linux

Вообще с линуксами есть две основные ветки развития дистрибутивов: это основанные на deb пакетах, и на rpm пакетах и есть еще. Дистрибутивы, построенные на деб пакетах пошли от линукса по имени debian, а дистрибутивы, построенные на rpm пакетах пошли от линукса по имени RedHat. На самом деле есть еще тьма дистрибутивов, которые вместо пакетов компилируют исходники, но это для тех очень бородатых нердов.

Мы будем использовать дистрибутивы, построенные на базе deb пакетов. Возьмем один из самых легковесных, который называется sparkylinux. По сути это дебиан, поверх которого установлена графическая оболочка. Ну и специализированный набор ПО под данную оболочку.

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

И так, первое что надо сделать это скачать образ установочного дистрибутива. Идем сюда https://sparkylinux.org/download/stable/ и качаем либо ISO image напрямую, либо если есть торрент-клиент то лучше torrent (так будет быстрее)

На компах в классе она уже скачана, лежит в общей папке, в папке Каташевцев.

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

Создаем виртуальную машину

Открывает virtualbox и тыкаем создать

либо если кто-то уже что-то делал на вашем компе, то сюда

Указываем имя, например, я выбрал KatashSparky.

Указываем путь к папке, в которой надо будет создать виртуальную машину (ни в коем случае не выбирайте флешку, даже если планируете работать с флешки, иначе установка займет очень много времени). А также выберите тип Linux, а версия Debian (64-bit)

тыкаем далее, указываем количество доступной оперативки, лучше не менее 2ГБ, в принципе все равно эти параметры всегда можно будет подкорректировать

теперь надо создать образ виртуальной машины, в принципе 10ГБ вполне нормальное место для работы, при желании его можно будет расширить

например, у меня рабочая система на линуксе, за 6 лет с последней чистой установки занято всего на 25ГБ из 40ГБ

тыкаем далее, а затем готово

Устанавливаем Sparky Linux

теперь тыкаем запустить

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

находим файлик

и жмякаем

открывается экран загрузчика linux, можно смело тыкать enter

ждем пока не увидим такое:

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

Теперь тыкаем Sparky Installer чтобы запустить установку

откроется такое окно

так как виртуальный экран очень маленький, лучше его чуток увеличить.

Тыкаем кнопку пуск и идем в настройки экрана

ставим разрешение побольше

Продолжим с установкой.

Выбираем часовой пояс, если вдруг не наш, тыкаем далее

клавиатуру не трогаем, тыкаем далее:

Размечаем диск

Теперь, самое хитрое. Настройка разметки диска. Выбираем Ручная разметка

откроется такое окошко, тыкаем Новая таблица разделов

выбираем разметку GPT:

увидим такое, тыкаем Создать.

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

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

Чтобы не запутаться есть определенные набор специальных папок, которые имеет смысл выносить на разные диски. Для большинства установок это следующие папки (они же точки монтирования)

• \ – корневая папка, аналог диска C:
• \home – папка домашних директорий юзеров

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

В общем поехали.

Создадим этот самый корень. Прописываем размер (8196МиБ), точку монтирования / и тыкаем Ок

увидим такое:

снова жмем создать. Теперь создаем раздел под загрузчик linux. У него не надо прописывать точку монтирования, просто указываем ему размер в 8МиБ и ставим флаг раздела bios-grub

еще раз тыкаем Создать.

Нам осталось создать точку монтирования под папки юзеров. Точка монтирования для папки юзеров обозначается через /home.

Размер можно не менять. Он автоматом пропишет все оставшееся место. Пишем только точку монтирования.

тыкаем Далее. Скорее всего выскочит такое окно

просто тыкаем Ок.

Теперь прописываем имя юзера и пароль

и снова тычем Далее. Откроется окно где прописаны указанные нами значения.

Тыкаем Установить и ждем:

когда установка закончилась, ставим галочку и тыкаем готово

когда сверху появится надпись, тыкаем Enter

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

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

Загрузится система, закрываем приветственное окно и если предложит обновления, тыкаем нет.

Подключаем авторасширение экрана

Чтобы было комфортнее работать с виртуалкой, надо настроить авторасширение экрана, а также двусторонний буфер, чтобы копировать данные между основной операционкой и виртуальной.

И так, подключаем виртуальный диск с дополнительными модулями для Linux

на рабочем столе появится ярлык подключенного диска, дважды кликаем на него

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

откроется терминал (он же консолька).

Пишем в него

sudo ./VBoxLinuxAdditions.run

жмем enter, вводим пароль (кстати пароль невидно, когда вы его вводите, так что вводите наощупь) и ждем

когда установка закончится. Выбираем вверху

и перезапускаем командой

sudo reboot

Теперь после запуска машины, можете просто растягивать окно виртуальной машины, и он сам будет подгонять разрешение linux.

Смотрим что у нас установилось

Запустим терминал. Нажмите Windows+T.

Если по какой-то причине у вас не открылось такое окно. То зайдите в настройки клавиатуры

кликните два раз и введите какую-нибудь другую комбинацию:

И так, давайте проверим какие диски у нас есть и насколько они заполнены.

Пишем команду

df -h

он выдаст нам список дисков, которые обозначены через /dev/sda* и сопоставленные им точки монтирования.

Желтая – это наша точка монтирования / которая соответствует месту куда установлена система. У меня свободно 2.2ГиБ

А синяя – это папка где будут хранится данные нашего юзера занята, там свободно 1.8ГиБ, то есть место вдовль.

Работает с командой ls

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

Давайте напишем следующую команду, чтобы увидеть список файлов и папок в корне системы. Пишем:

ls -lah /

тут куча папок, с частью из которых мы познакомимся на лекциях.

Вообще, это же можно увидеть и если просто открыть слева проводник:

Когда вы запускаете консоль, она запускается всегда в некой конкретной папке. По умолчанию – это папка текущего юзера. То бишь наша домашняя директория. И так пишем

ls -lah

увидим список папок в нашей домашней папке

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

нас сейчас интересует папка home, помните мы при установке назначали точку монтирования /home. Это вот она и есть.

То есть хотя она и находится в корневой папке, на самом деле это прямо отдельный диск. Но для нас визуально это никак не проявляется.

Давайте откроем ее и глянем что в ней есть.

в ней сейчас две папки:

• lost+found – папка на случае повреждения файловой системы, в которой будет лежать восстановленные файлы (нам не понадобится, я в жизни кстати ни разу не сталкивался с этой папкой)
• m – папка с именем вашего юзера, у меня юзер называется m поэтому, и папка так называется. У вас будет свое имя.

зайдем в папку нашего юзера. Увидим такое

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

и напишем команду

ls

увидим те самые папки

на самом деле, в этой папке есть еще скрытые файлы.

Чтобы их увидеть добавьте к команде флаг a, вот так:

ls -a

о уже интереснее. Их кстати можно включить для отображения и в проводнике. Просто нажмите сюда:

вот теперь другое дело

Вернемся к консоли.

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

ls -a -l

кстати флаг можно объединять и писать вот так

ls -la

получим тоже самое

Полезности при работе с консолью

1. Чтобы повторить предыдущую команду нажмите кнопку стрелочка вверх. Так на самом деле можно перебирать все предыдущие команды.
2. Чтобы очистить терминал напишите clear и нажмите enter
3. Чтобы не писать название команды целиком можно написать часть команды, например cl и нажать TAB, и терминал за вас продолжит команду. Правда иногда команд может быть много и он будет выдавать список возможныз вариантов.

[Бонус] Подключаем существующий диск на другом компьютере

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

На самом деле вам важно таскать даже не виртуальную машину, а файл с виртуальным диском

Допустим вы приходите и раз нет ваших виртуальных машин

шо делать?

А все просто, тыкаете создать

выбираете использовать существующий диск

далее тыкаете добавить

и находите файл в который устанавливали систему

ну и тыкаете создать

и запускаете как обычно

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

И так начнем с такой простой вещи как установка приложений.

В линуксах редко приходится скачивать программу из интернета вручную и ставить ее руками. Как правило все делается через использование специального инструмента для управления пакетами

Называется он apt (advanced packaging tool). Рассмотрим сразу на примере,

Устанавливаем git

нам точно понадобится git в скором времени, давайте его и поставим

Откроем консольку Windows+T и напишем

apt install git

увидим в ответ такое:

дело в том, что в линусках все операции с системой должны проходить в режиме суперпользователя (типа админа). Это чем-то напоминает, когда в винде у вас просят подтверждение на выполнение каких-то действий типа

но там у вас окошко выскакивало, а тут что делать?

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

apt install git

пишем

sudo apt install git

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

если вы дома, то скорее всего у вас запустится установка

если не запустилась попробуйте сначала ввести команду

sudo apt update

она обновит кеш пакетов. Потому снова попробуйте

sudo apt install git

Если и это не помогло. То вы судя по всему в политехе. А там интернет работает через прокси, поэтому надо сделать пару дополнительных операций.

Сначала напишите команду

sudo visudo

затем появится консольный редактор файла. Добавьте в файл строчку

Defaults env_keep = "http_proxy https_proxy ftp_proxy" 

теперь сохраните и закройте редактор. Для этого Нажмите Ctrl+O затем Enter, затем Ctrl+X.

Теперь надо ввести еще одну команду перед установкой

export http_proxy="http://172.27.100.5:4444"

команду придется вводить каждый раз перед какими-нибудь действиями с интернетом. И после уже вводим

sudo apt update
sudo apt install git

Ну и ждем

иногда он кстати может спросить какого-нибудь подтверждения типа [Д\н] просто тыкайте Enter

Так, давайте теперь проверим что git установился, напишем

git

и увидим

что означает что все работает как надо.

Создаем репозиторий

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

Но, так как создавать проект где попало не хочется, давайте сначала поймем где мы вообще находимся. Когда вы работаете из терминала, вы всегда находитесь в какой-то папке.

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

ls -la

у меня вывелось вот такое:

синеньким обозначены папки, белым – файлы. Если у вас не совсем похоже на мое, то переживать не стоит, это норма.

Чтобы понять что-за это папка вы можете написать

echo $PWD

$PWD – это так называемся переменная среды, а echo команда которая позволяет выводить значение переменных среды.

PWD значит present working directory (то есть текущий рабочий каталог)

в линуксе целая тьма переменных среды, например, есть переменная в которой указан текущий юзер

echo $USER

получится что-то такое

весь список можно запросить через команду env

Давайте теперь создадим папку под проекты, я назову ее projects, вы можете назвать как вам хочется. Для создания папки используется команда mkdir

теперь зайдем в эту папку, для этого используется команда cd после которой указывается пусть к папке в которую хотим перейти

cd projects

кстати не обязательно полностью писать пусть вы можете написать часть пути и нажать Tab и терминал автоматом допишет за вас слово, либо предложит список комбинаций.

Кстати обратите внимание на значок тильды ~

то есть в моем случае в папку /home/m

Создадим теперь гит проект, для этого напишем команду

git init project01

теперь зайдем в папку с проектом

cd project01

и посмотрим, что в ней лежит

ls -la

то есть создавая пустой репозиторий мы по сути просто создаем папку со специальной папкой .git, кстати если написать просто

ls -l

то мы эту папку не увидим, потому что в линуксе все папки и файлы которые начинаются с точечки являются скрытыми. Как правило в них содержится всякая системная информация.

Теперь создадим файлик README.md с описание проекта.

В линуксе тьма способов создать файл. Самый простой – это команда touch

touch README.md

команда создаст пустой файл. Вообще создание файлов на самом деле не главное назначение файла touch, в основном его используют для манипуляций датами создания/редактирования файла.

Давайте создадим сразу первый коммит, сначала добавим файлик README.md в стейдж

git add README.md

а затем создадим коммит

git commit -a -m "первый коммит"

и получим такую ошибку

дело в том, что сначала надо указать свое имя и почту, которые будут использоваться при указании авторства коммита в истории.

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

и пробуем сделать коммит по новой. Кстати, чтобы не вводить команду по новой, просто понажимайте клавишу вверху, и у вас начнется перебираться список последних комманд:

И теперь подключим наш проект к гитхабу.

Подключаемся к github

Идем на github и создаем новый репозиторий

теперь подключим папку к проекту, тыкаем вверху кнопочку ssh и выполним вот эти команды которые предлагает нам github

при выполнении последней команды увидим такое сообщение

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

Подключаемся к github по ssh

Подключая репозиторий, github по умолчанию предлагает использовать ssh протокол для общения клиента с сервером.

В этом случае авторизация происходит не по логину/паролю, а через пару цифровых ключей.

И вот это сообщение которое тут всплыло у нас пока просто спрашивает, стоит ли нам считать сервер github доверенным.

Тут мы пишем в ответ yes, но так как цифрового ключа мы пока не создавали, то команда отправки на сервер не сработает:

И так давайте создадим ключик для подключения.

Авторизация через ключи прикольнее чем авторизация черз юзер пароль.

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

Ключи создаются один раз и потом на автомате подхватываются при авторизации, не надо вводить никакие пароли.

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

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

Создаем пару ssh-ключей

И так давайте создадим ключики. Для этого используется команда ssh-keygen

В качестве параметра указывается тип ключа, github рекомендуем использовать схему ed25519 https://ru.wikipedia.org/wiki/EdDSA так что ее и будем использовать, пишем

ssh-keygen -t ed25519

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

echo $HOME

ну либо просто запомнить, что ваша домашняя директория – это всегда /home/имя_вашего_пользователя, в моем случае будет /home/m, то есть я для пути к ключу укажу

/home/m/.ssh/linux_project01

вас еще попросят ввести парафразу (это пароль для ключа), но ее можно просто оставить пустой, то есть два раза тыкнуть enter, в результате увидим что-то такое:

кстати картиночка в конце которую вы видите это визуальное представление ключа. Алгоритм генерации можно почитать тут https://russianblogs.com/article/8271690010/.

Опять же нужна для случаев, когда люди серьезно озабочены безопасностью и при каждом соединении с удалённым сервером у них включен режим выводить это картинку. Цель – визуально запомнить, как выглядит ключ, и если произошла подмена ключа, то картинка поменяется, а оператор должен среагировать на это – ну, как минимум, заподозрить что-то не ладное.

Теперь давайте глянем что-за файлики сгенерились:

ls ~/.ssh -la

так как мы владельцы то можно глянуть содержимое файлов. Тот файл, который заканчивается на .pub – это публичный ключ, давайте выведем его содержимое. Самая простая команда для вывода текста из файла называется cat

cat ~/.ssh/linux_project01.pub

увидим его содержимое

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

его нельзя никому показывать =О

Подключаем ключи к github

Так, теперь надо подключить ключи к github. Мы будем использовать так называемые deploy ключи, которые позволяют создавать отдельный ключ под каждый репозиторий, идем сюда и тыкаем add deploy key

и добавляем ключ

теперь надо подключить этот ключ в линуксе. Чтобы гит понял, что ему надо использовать эти ключи для соединения их надо прописать в конфигах ssh. Подробнее это описано тут https://docs.github.com/en/developers/overview/managing-deploy-keys#using-multiple-repositories-on-one-server

Интересуют нас вот эти строки:

То есть нам надо создать файлик ~/.ssh/config, создавать мы уже умеем, давайте переместимся в папку ~/.ssh

cd ~/.ssh

и создадим файл, уже с помощью известной нам команды touch

Теперь собственно вопрос, а как его редактировать?

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

Вводим

nano config

и видим

пишем туда, как будто это простой текстовый файл

Host github.com
    IdentityFile=~/.ssh/linux_project01

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

тыкаем Ctrl+O

и жмем Enter

Все теперь можем выйти из редактора. Для выхода надо нажать Ctrl+X

теперь вернемся в папку с репозиторием

cd ~/projects/project01/

и попробуем снова команду

git push -u origin main

хм, чего-то не работает…

А! Если прочитать ошибку, то увидим что там написано:

Bad owner or permissions on /home/m/.ssh/config

Тут дело в том, что создав файлик config мы не настроили ему права доступа.

Давайте еще раз глянем содержимое папки .ssh

ls ~/.ssh -la

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

chmod 600 ~/.ssh/config

пробуем еще раз отправить наш репозиторий в github

git push -u origin main

о, поехало:

красота =)

И так, теперь поговорим об автоматизации. Ведь линукс это в первую очередь система, в которой можно программировать как душе угодно и автоматизировать все что только придет в голову.

Допустим мы в прошлый раз создавали папку под проект, инициализировали там репозиторий добавляли там файл README.md, подключали его к гиту, создавали ключики.

И каждую команду нам приходилось вводить вручную. Что конечно было лениво

Когда вам часто приходится выполнять какие-то операции, было бы неплохо это как-то упростить. Например, так чтобы вам вместо ввода 10 команд достаточно было ввести одну команду.

Автоматизируем создание проекта

Давайте напишем скрипт который объединяет все эти команды. Но сначала нам надо определится со списком команд:

• создать папку через mkdir
• инициализировать репозиторий в папке
• создать файлик README.md
• добавить файл в репозиторий
• создать первый коммит с сообщением “первый коммит”
• создать ключи
• добавить ключи в config

теперь попробуем вывести все эти команды

mkdir new_project
git init
touch README.md
git add README.md
git commit -a -m "первый коммит"

давайте пока реализуем без ключей.

Теперь создадим папку project03 и будем экспериментировать в ней

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

в общем по идее у нас должна появится папка new_project, внутри которой будет лежать файлик README.md

посмотрим, что у нас получилось (через ls -la):

то есть у нас в текущей папке появилась папка new_project, что уже неплохо, но файл README.md создался не внутри папки new_project, а в текущей. Ну и папка .git не там оказалась не в папке new_project, а в текущей

Глянем что в папке new_project:

кстати давайте поставим программку которая позволяет просматривать папки не по одной, а сразу в виде дерева. Пишем команду

sudo apt install tree

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

ну установлен и хорошо, давайте тогда воспользуемся ей, пишем

tree 

и видим структуру

тут не очень наглядно, давайте добавим руками файлик в new_project

touch new_project/test_file.txt

и снова посмотрим содержимое

можно добавить флаг -a тогда увидим и содержимое скрытой папки .git

Так, ну в принципе проблема понятна. Надо чтобы файлик и репозиторий создавались не в текущей папке, а в папке new_project, а как это сделать?

Надо просто после создания папки перейти в нее через

cd new_project

Давайте, все почистим. Для удаления файлов и папок используется команда rm от слова remove (англ. удалить). Запускаем:

чтобы удалять папки надо добавить флаг -r (от слова recursive, то бишь рекурсивно),

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

чтобы прервать выполнение команды тыкайте Ctrl+C и чтобы вопросы не возникали добавьте флаг -f (от слова force, то бишь «принуждать» по-английски)

вызываем tree -a чтобы убедится, что в каталоге ничего не осталось:

ну вроде все ок.

Вернемся к нашему набору команд. Напоминаю, они у нас такие

mkdir new_project
git init
touch README.md
git add README.md
git commit -a -m "первый коммит"

надо добавить переход в папку new_project

mkdir new_project
cd new_project # добавил
git init
touch README.md
git add README.md
git commit -a -m "первый коммит"

Пробуем выполнять

красота =О

Немного о встроенной документации man

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

пожалуйста! Полная документация! К сожалению, только на английском, но шо поделаешь =) Кстати, чтобы из нее выйти надо нажать q (от слова quit – то бишь выход по-английски)

Создаем скрипт

Давайте теперь попробуем это как-нибудь улучшить. Удалим папку new_project

cd .. # выйдем из папки
rm -rf new_project

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

Создадим файл. Вообще для создания файла не обязательно сначала писать touch, а потом уже nano, можно просто после nano указать имя файла. Для файлов с командами bash принято указывать расширение *.sh

nano create_git_project.sh

открывается редактор, в который загоняем команды

сохраняем через Ctrl+O и выходим Ctrl+X

теперь собственно надо его как-то запустить. Для этого можно написать так

bash create_git_project.sh

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

Тут кстати важное отличие от windows. В винде есть фиксированный набор расширений файлов, которые винда на автомате рассматривает как исполняемые ну там exe, bat, msi и т. д.

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

Для добавления флага используется команда chmod. Что за такие флаги спросите вы. А мы на самом деле их уже видели. Давайте еще раз посмотрим. Выполним команду ls -l

у каждого файла (папка тоже считается за файл есть 10 флагов)

если где-то стоит прочерк — значит права отсутствуют. Кстати может возникнуть вопрос, а что за владельцы и группы у файла? А это надо глянуть вот сюда

Ну с владельцем вроде понятно, кто файл создал тот им и владеет. А группа — это такой способ объединять пользователей по какому-нибудь признаку. По умолчанию, когда создается новый пользователь, создается группу с тем же именем что и пользователь. Ее можно рассматривать как своего рода группу друзей пользователя. Туда можно добавить других юзеров и дать им права на манипуляции какими-то файлами.

Весь список групп хранится в файлике /etc/group, можно посмотреть его:

cat /etc/group

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

Для таких целей есть еще одна команда которая позволяет выводить файл не весь целиком а как будто вы создали мини консольку со скроллом внутри настоящей консоли со скроллом =)

less /etc/group

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

выйти из нее можно так же как из man, через нажатие клавиши q

Делаем файл исполняемым

Ну что-то я отвлекся. Вернемся к нашему желанию сделать файл исполняемым. Для того чтобы сделать файл исполняемым надо добавить ему флаг x делается это так

chmod +x create_git_project.sh

но тут сразу надо глянуть что возможность выполнять файл мы добавили всем и юзеру (user) и группе (group) и остальным пользователям (other).

Давайте запретим другим пользователям запускать этот файл. Для этого надо вместо +x использовать -x и чтобы убрать флаг только у остальным пользователей надо добавить букву o от слова other

chmod o-x create_git_project.sh

так, ну ладно, исполняемым файла мы сделали. Запускать то как?

А тут все просто, мы теперь вместо того чтобы писать bash имя_файла просто пишем

./create_git_project.sh

только не забудьте удалить папку new_project

и тут важно запомнить что указывать ./ надо обязательно. Потому что когда вы вызывает какую-то команду без ./, то терминал начинает искать команду среди установленных приложений, а также в папках указанных в специальной переменной $PATH

Работаем с входными параметрами

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

Подправим наш скрипт

echo $0
echo $1
echo $2
exit 0 # добавил выход из скрипта чтобы не создавать пока проект

mkdir new_project
cd new_project
git init
touch README.md
git add README.md
git commit -a -m "первый коммит"

и глянем что это выдаст

• то есть $0 попадает название файла, который мы запустили
• $1 – это первый параметр который мы передали, то есть 123
• $2 – это второй параметр который мы передали, причем так как мы добавили кавычки вокруг фразы, то он расценил “новая папка” как одно значение

Теперь, когда у нас есть доступ к параметрам мы можем комбинировать их, и строить, например, какие-то фразы:

echo "Ваша программа называется: $0"
echo "Ваш первый параметр: $1"
echo "Ваш второй параметр: $2"
exit 0

то есть даже не надо каких-то хитрых комбинаций по типа format использовать, просто берем и загоняем в строку. А bash автоматом подставит значения:

при необходимости можно вводить и переменные:

echo "Ваша программа называется: $0"
echo "Ваш первый параметр: $1"
echo "Ваш второй параметр: $2"

# тут важный момент, после название переменной не должно быть пробела
my_var="первый: $1 второй: $2" 

# переменную вставляют в текст оборачивая в ${}
echo "Значение my_var = ${my_var}"

exit 0

проверяем:

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

echo "Ваша программа называется: $0"
echo "Ваш первый параметр: $1"
echo "Ваш второй параметр: $2"

my_var="первый: $1 второй: $2"
echo "Значение my_var = ${my_var}"

new_folder_name="project_$1"

# при обращении к переменной надо добавлять ей знак доллара
mkdir $new_folder_name

exit 0

запускаем, должна создаться папка с именем project_123:

красота =)

Пишем значения переменных в файл

Ну и вишенка на торте! Вы можете значения переменных записывать в файл. Для этого используется оператор потока >

Работает так:

new_folder_name="project_$1"
mkdir $new_folder_name

text="Значение второй переменной $2"

# то есть echo $text > можно проинтерпретировать как
# запиши в файл "${new_folder_name}/README.md" значение $text
# кстати файл не обязательно создавать заранее, он будет создан автоматом
echo $text > "${new_folder_name}/README.md"

exit 0

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

new_folder_name="project_$1"
mkdir $new_folder_name

text="
Всем привет! =) \n\
Вот вам значение второй переменной: $2
"

# и тут добавляем флаг -e
echo -e $text > "${new_folder_name}/README.md"

exit 0

Ну и все теперь можно задание пилить

Рассмотрим как более хитро управлять поведением скрипта.

Например, изучим давно нам уже привычный в других языках оператор условия if.

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

Мы сначала рассмотрим старый синтаксис проверки bash команд, потому что его еще часто можно встретить, и чтобы у вас не возникало проблем в попытке его проинтерпретировать.

Оператор сравнение

В linux есть команда test, она используется для сравнения значения аргументов. Синтаксис прост до безобразия:

test выражение

так как это команда (ну или правильнее говорить, что это программа), то и при вызове надо выполнять требование к указанию аргументов. Например, если вы хотите сравнить два числа, то надо писать так

test 3 = 5

то есть тут три аргумента, первый – 3, второй – это знак =, ну и третий – 5, обязательно через пробел.

попробуем ее вызвать:

хм, а где ж результат?

Тут дело в том, что результат функции определяется кодом возврата программы. Помните в C++ вы писали в конце main функции:

return 0;

так вот этот 0 – и был кодом возврата вашей функции. В интерпретации bash, 0 – это успешный результат, и интерпретируется как ИСТИНА, если же программа возвращает что-то большое нуля – то считается что произошла ошибка, и это самое положительное число и есть номер ошибки.

Ну и что нам с того? А с того, что выполнив сейчас команду, да и в принципе выполнив любую команду, был возвращен какой-то код возврата.

Код возврата последней программы, хранится в специальной переменной $?, как и всякую переменную ее значение можно вывести через echo

echo $?

если мы видим положительное значение, значит результат работы программы ложь.

Давайте попробуем проверить что-нибудь точно истинное

test 1 = 1
echo $?

О! получили 0, значит результат истина.

С помощью этой же программы можно проверить, например, существование файла

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

test 5 > 3

а потом

test 1 > 3

и удивитесь что получите один и тот же результат. А как так?

Дело в том что знак > это зарезервированный символ в bash, помните мы с помощью него текст в файл загоняли. Так вот задача этого символа перенаправлять результат функции причем не код возврата, а именно выходной поток (который, например, получается через Console.WriteLine в C#) в файл.

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

О как! А где же файл?

А вот и он:

пустой, между прочим.

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

Так, ну ладно, к чему я собственно все это рассказываю. А к тому что оператор if в bash, проверяет не значение выражение, а код возврата программ, которое пишется после него.

Например, я могу создать файлик if_example.sh, написать в него такой скрипт

if test 3 -ge 1
then
    echo "3 больше 1"
fi

сделать его исполняемым

chmod +x if_example.hs

и запустить

если же загнать какое-нибудь ложное выражение

if test 3 -ge 7
then
    echo "3 больше 7"
fi

то ничего не выведется

Вроде все логично, но писать test весьма непривычно особенно если вы уже имеете опыт с каким-нибудь другим языком. И в linux в стародавние времена пошли на одну хитрость, они создали программу которую назвали [ и вызов этой программы эквивалентен вызову test.

И это дало возможность писать проверку условия как

if [ 3 -ge 7
#...

и первое время так даже можно было писать. Что выглядело с одной стороны более похоже на нормальный язык. Но все-таки, одна открывающая скобка… В общем, со временем использование только открывающей скобки запретили и писать теперь надо

if [ 3 -ge 7 ]
#...

Кстати остатки этого наследия все еще обитают в системе. Например, в линуксе вы можете узнать расположение программы с помощью команды which, вот так:

в этой папке /usr/bin лежит целая тьма всяких программ

там можно найти даже наш git. И там есть команда под именем [

А вообще, на самом деле, современный bash уже не использует ни программу test ни программу [, они встроенны в bash и работают уже как часть языка bash.

Проверка нескольких условий

Иногда может захотеться проверить несколько условий, в этом случае у вас есть несколько вариантов. Первый вариант есть результат того что bash оперирует вызовами программ. А в линуксе можно запустить последовательно несколько команд вот так:

test 1 -lt 2 && test 2 -lt 5

в этом случае если test 1 -lt 2 вернет истину (то есть код возврата 0), то будет выполнена вторая команда, которая test 2 -lt 5

если же test 1 -lt 2 вернет ложь, то вторая команда выполняется не будет. Можно, например, даже так писать

test 1 -lt 2 && ls -la

то есть если 1 меньше 2 то выведи файлы в папке.

то есть в первом случае список файлов вывелся, а во втором уже нет. Потому что условие было ложно.

Ну и как есть оператор && (логическое И) так и есть оператор || (логическое ИЛИ), который работает в точности наоборот. Если первая программа вернула ложь, то выполняется вторая команда, а если вернулась истинна, то не выполняется.

Давайте проверим:

То есть в принципе такими однострочниками можно пользоваться как перключателями типа выполнить или не выполнить ту или иную программу.

Но понятно, что такое применимо только в очень простых случаях. А если мы хотим проверять сразу несколько условий в if. Как это написать?

Просто вспоминаем что после if пишется список команд для исполнения интерпретатором. Значит мы можем писать так

if test 1 -lt 2 && test 2 -lt 5
then
    echo "Привет"
fi

А так как программе test соответствует программа [, то можно переписать вот так

if [ 1 -lt 2 ] && [ 2 -lt 5 ]
then
    echo "Привет"
fi

но это опять не очень привычно, теперь вот сразу две пары скобок писать надо. Поэтому современный bash поддерживает новый синтаксис проверки условий через двойные квадратные скобки

if [[ 1 -lt 2 && 2 -lt 5 ]]
then
    echo "Привет"
fi

первое время конечно может пугать, но потом привыкаешь.

Управление поведением ssh-keygen

Вы можете передать в ssh-keygen дополнительные параметры. Например, путь к файлу с ключем, через флаг -f

ssh-keygen -t ed25519 -f "путь_к_файлу"

чтобы ssh-keygen не просил passphrase, надо указать флаг -N с пустым параметром

ssh-keygen -t ed25519 -N ""

ну и чтобы функция не выводила никаких сообщений можно добавить флаг -q (от слова quiet - тихо) без параметра.

ssh-keygen -t ed25519 -q

Добавление текста в файла

Мы уже выше пробовали создавать файлы на лету через оператор перенаправлениz потока вывода >.

Этот оператор всегда создает новый файл. Либо перезаписывается уже существующий. Ну типа

echo "Привет" > "new_file.txt"

если попробовать написать эту команду еще раз

echo "Пока" > "new_file.txt"

Так вот, есть способ сохранять содержимое файла, для этого надо вместо оператора > использовать оператор >>.

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

Вот таким не хитрым способом можно добавлять содержимое в уже существующий файл.

Чтобы создать репозиторий автоматически нам потребуется установить утилиту для работы с вебом

sudo apt install curl

теперь можно общаться с гитхабом, например, запросить список репозиториев

curl -u "ИМЯ_ВАШЕГО_GITHUB_АККАУНТА" https://api.github.com/repositories

Правда надо будет правда ввести пароль от юзера, чтобы увидеть данные.

Чтобы бы получить возможность создавать репозитории надо создать токен для авторизации

затем скролим вниз и находим там Developer Settings

вводим имя и ставим галку

ну и тыкаем внизу

откроется новое окно с токеном, который надо скопировать, сделать это можно ровно один раз, посмотреть его второй раз не выйдет

теперь можно создать репозиторий, для этого пишем

curl -X POST -u "ИМЯ_ВАШЕГО_GITHUB_АККАУНТА:ВАШ_ТОКЕН" \
    https://api.github.com/user/repos \
    -d '{"name":"test124"}' > repo.json

результат сохранится в файлик repo.json, там будет что-то такое

{
    "id": 458448401,
    "node_id": "R_kgDOG1NeEQ",
    "name": "test124",
    "full_name": "SevenLines/test124",
    "private": false,
    "owner": {
        "login": "SevenLines",
        "id": 5500999,
        "node_id": "MDQ6VXNlcjU1MDA5OTk=",
        "avatar_url": "https://avatars.githubusercontent.com/u/5500999?v=4",
        "gravatar_id": "",
        "url": "https://api.github.com/users/SevenLines",
        "html_url": "https://github.com/SevenLines",
        "followers_url": "https://api.github.com/users/SevenLines/followers",
        "following_url": "https://api.github.com/users/SevenLines/following{/other_user}",
        "gists_url": "https://api.github.com/users/SevenLines/gists{/gist_id}",
        "starred_url": "https://api.github.com/users/SevenLines/starred{/owner}{/repo}",
        "subscriptions_url": "https://api.github.com/users/SevenLines/subscriptions",
        "organizations_url": "https://api.github.com/users/SevenLines/orgs",
        "repos_url": "https://api.github.com/users/SevenLines/repos",
        "events_url": "https://api.github.com/users/SevenLines/events{/privacy}",
        "received_events_url": "https://api.github.com/users/SevenLines/received_events",
        "type": "User",
        "site_admin": false
    },
    // ...
}

чтобы вытащить конкретное поле то можно поставить еще одну утилиту для работы с json форматом json

sudo apt install jq 

можно, например, вывести ssh_url, который потом можно использовать при привязке репозитория вот так:

jq ".ssh_url" -r repo.json

А имя пользователя например вот так:

jq ". owner.login" -r repo.json

Как правило хочется результат сохранить в переменную для этого вызывайте функцию вот так:

SSH_URL=$(jq ".ssh_url" -r repo.json)

Ну а чтобы подключить ключик надо использовать следующий запрос к серверу github

KEY=$(cat ~/.ssh/path_to_key.pub)
curl -u "$USER:$TOKEN" -X POST https://api.github.com/repos/$USER/$REPO_NAME/keys -d "{\"key\":\"$KEY\"}"

В принципе, зная это, можно собрать полностью автоматизированный генератор репозиториев =)