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

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

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

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

Итак, кому подойдёт эта статья:

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

• тем, кто преимущественно работает в графической оболочке, но также имеет дело с большим количеством рутинных операций на unix-машинах

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

А также если вам часто приходится:

• копаться в недрах кубернетеса среди логов микросервисов,

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

Содержание

Введение

Принцип первый: hotkeys

Принцип второй: упрощение команд

Принцип третий: использование алиасов и переменных

Небольшой бонус

Выводы

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

Данная статья содержит упор на:

• совместном использование GUI (привычной и интуитивно понятной нам графической оболочки) и

• выполнении команд в терминале (текстовая среда ввода/вывода, позволяющая запускать оболочку и выполнять команды на компьютере).

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

Введение. GUI или CLI?

Управлять операционной системой можно двумя способами:

1. через графическую оболочку и

2. через консоль/терминал.

GUI - (Graphical user interface) - та самая графическая оболочка, наиболее известная нам по системе Windows + вспомните любой браузер (окна, кнопки, поля для ввода данных, чекбоксы и т. д.). Клики мышкой и последующие заполнения нужных нам полей - основной способ управления системой.

CLI - (Command-line interface) - интерфейс командной строки - другой вариант взаимодействия человека и компьютера. Ввод текста в терминал/консоль - основной способ общения с системой.

В интернете есть много статей на тему GUI против CLI и так как наша статья немного проходится по ней, я сделаю краткий обзор.

Обычно битва этих титанов (в невыгодном для графики виде) выглядит так:

«Уберите руку с клавиатуры и возьмите мышь, перейдите в панель запуска программ и найдите нужный текстовый редактор. Откройте программу. Щелкните в области редактирования текста. Уберите руку с мыши и введите „Hello World“ в файл. Уберите руку с клавиатуры и возьмите мышь, перейдите к значку или пункту меню, чтобы сохранить файл. Выберите место для его сохранения. Закройте файл.

Теперь, вместо этого, введите Ctrl + Alt + T (или любой другой способ вызвать терминал) и введите:
echo 'Hello World' > ~/myfile.txt».

Взято у Джейсона Престона с одного из блогов (к сожалению, потерял ссылку).

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

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

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

   Сравните сами что быстрее: зайти, кликая мышкой, в какую-нибудь глубоковложенную папку с логами или просто вбить её путь в консоли? (при условии, что вы его знаете)

2. Меньше нагрузка.
   
   По сути выполнение операций в графической оболочке - это то же самое общение с операционной системой. Просто сюда добавляются дополнительные накладные расходы на графику, которые необходимо визуализировать и иногда обновлять каждые несколько секунд.
   
   (Например, открыть в проводнике папку "Downloads" - это та же программа "cd ~/Downloads", просто со "спецэффектами" и озвучкой).
   
   Эта нагрузка на графику часто занимает больше памяти, чем сама задача.

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

3. Автоматизация.
   
   Выполнение повторяющихся задач в GUI зачастую весьма рутинно и удручающе, так как занимает довольно много времени и моральных сил.
   
   В CLI те же задачи всегда можно автоматизировать с помощью скриптов или сторонних программ - в зависимости от цели, которую вы себе ставите.

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

"Хороший системный администратор - это ленивый системный администратор".

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

Если вы работаете на unix-машине, то учитывайте, что изначально она затачивалась на чистую работу с консолью, а значит вы можете значительно ускорить свою работу, просто запомнив и начав применять некоторые трюки по работе с CLI (и не только).
Вот они:

Hotkeys

Это комбинации клавиш, нажимая на которые вы совершаете определённые операции в системе.

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

Hotkeys бывают разных видов, мы рассмотрим три из них:

• Хоткеи DE (Desktop Environment)
  Всё то, что вы используете в графической оболочке для ускорения своей работы (например, Ctrl + W (для закрытия активной вкладки в бразуере), Alt + F4, Ctrl + Alt + Delete и т. д.)

• Хоткеи терминального эмулятора
  Комбинации клавиш, ускоряющие работу в терминале

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

Второй элемент в ускорении работы с терминалом - оптимизация набора команд.

Оптимизация написания команд

Как это всё можно оптимизировать?

1-ый пример приведём на kubernetes, но, как я покажу в конце этого блока, данное правило касается довольно многих команд в принципе.

Типичная проверка состояния пода в нэймспейсе (а затем и чтение логов нужного нам микросервиса) выглядят так:

kubectl get po -n my-namespace
kubectl logs my-pod-blablabla-blabla -n my-namespace

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

Увеличить скорость работы в этом примере можно двумя способами:
1-ый способ - проведя перестановку аргументов:
Команды можно записать следующим образом:

kubectl -n my-namespace get po
kubectl -n my-namespace logs my-pod-blablabla-blabla

В данном случае нам уже не нужно возвращаться в середину команды, чтобы стереть нужный участок. Мы жмём стрелку "вверх", чтобы вызвать предыдущую команду и сразу можем жать Backspace, стирая ненужное и записывая нужное.

2-ой способ - использование hotkey.
Можно сразу зажать Ctrl и, дважды нажав "W", стереть последние слова. Или, если вы не оптимизировали порядок аргументов, прыгнуть через несколько слов комбинацией "Ctrl + Left" и переписать нужные аргументы.
Идеально - использовать оба способа:

1. Помните, что у многих команд (начиная с таких как docker, kubectl, java и заканчивая unix-овыми типа find, grep, ls, etc.) порядок аргументов и их значений может идти в случайном порядке.
   (Исключения составляет небольшая группа аргументов, типа "-maxdepth" у find, которые классифицируются как global options и должны помещаться в начале. Но при попытке выполнить команду ошибочно, сама программа вам об этом скажет).

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

2. Использовать hotkeys правда важно и правда ускоряет муторные операции категории домотать до нужного места, стереть, переписать, проверить.

2-ой пример:

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

grep -C 50 seek_word /opt/srv/logs/srv_important.log

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

Уже здесь можно довольно быстро ускориться, либо сразу прыгнув в начало консоли "Ctrl + A" и/либо перескочив нужные нам слова "Ctrl + Right | Ctrl + Left".

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

cat /opt/srv/logs/srv_important.log | grep -C 50 seek_word

Поначалу это может казаться усложнением: мы сперва даём команду прочитать все логи, а затем перенаправляем вывод на grep, но если присмотреться к этому трюку повнимательнее, то мы увидим, что теперь, чтобы переписать ту часть, где мы что-то ищем, нам достаточно вызвать предыдущую команду и один раз нажать "Ctrl + W".

Однако при таком подходе мы всё равно вынуждены либо писать первую команду целиком, либо искать её по истории сообщений командой:

history | grep cat (подробнее про манипуляции с введёнными ранее командами, history и её переменными см., например, rus-linux.net)

Однако есть и другой метод, чтобы избегнуть этой части рутины: просто написать небольшой bash-скрипт.

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

#!/bin/bash

cat /opt/srv/logs/srv_important.log | grep -C 40 "$1" --color=auto

Теперь вам достаточно назвать этот скрипт с какой-нибудь уникальной буквы (чтобы после неё можно было сразу добивать tab'ом всё название, в этом примере я назову srv_log.sh), сделать его исполняемым и написать в командной строке

bash s<TAB> seek_word

Всё: перед вами лог и вам не нужно тратить время для набора всей команды или поисков по истории команд.

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

Сокращение команд и длинных аргументов

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

где нужны разные переменные в зависимости от типа окружения/используемых стендов/чего-бы-то-ни-было-ещё, то можно загнать их в alias или в переменные в своём .bashrc
(bash run command - исполняемый файл, который содержит кастомизацию и сокращения для работы в bash-оболочке.)

Как устроены алиасы:

Возвращаясь к нашему примеру, мы можем создать свои переменные, дописав их, к примеру, в конец своего .bashrc.
(А лучше - создать отдельный файл .bash_aliases в своей домашней директории и вносить всё в него.
Так, для переноса всех ваших настроек можно просто перекинуть этот файл на нужный хост, сохранить его в гите и т. д. Благодаря тому, что в .bashrc есть строчки:

if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi

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

Возвращаясь к нашему примеру, ваши настройки могут выглядеть так:

export sand='gitlab-ci-sand-awesome.ru:9092'
export test='test-gitlab-ci-node-awesome.ru:9092'
export pred='pred-gitlab-ci-node-brilliant.ru:9092'
export prod='prod-gitlab-ci-node-amazing.ru:9092'

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

kafkacat -C -b $sand -t nameTopic -o beginning
kafkacat -C -b $test -t nameTopic -o beginning
kafkacat -C -b $pred -t nameTopic -o beginning
kafkacat -C -b $prod -t nameTopic -o beginning

($ для bash обозначает, что сразу после этого знака идёт переменная.)

И нам не нужно лезть в values/сторонний файл/куда-либо ещё, где мы храним все эти названия, после чего делать copy-paste в консоль или ещё как-либо тратить своё время на то, чтобы прочитать сообщения из нужного источника.
(Главное перезагрузить оболочку или набрать команду bash, чтобы он заново считал переменные из bashrc).

Что касается alias, их тоже полезно использовать в своей среде.

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

Для этого нужна команда вроде:
cd /mnt/tmp/nfs/docs/2024-05-30 (день написания данной статьи).

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

alias pn='cd /mnt/tmp/nfs/docs/'$(date +%F)' && ls -l'

Так что в итоге я вбиваю в терминале pn, жму Enter, и он переходит в директорию:

/mnt/tmp/nfs/doc/2024-05-30, после чего выполняет команду ll (или, вернее, ls='ls --color=auto' - помним про alias) и я сразу вижу всё содержимое этой директории.

Главное - подобрать понятную для вас мнемонику.
Я, например, pn расшифровываю для себя как path to nfs.

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

Объединиться и коллективно обсудить как можно сделать свою работу проще - довольно хороший план, поскольку тогда вы сможете написать общий файл ~/.bash_aliases и ускорить работу всей команды.

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

Из бонусов: можно настроить автодополнение в кубере таким образом, чтобы вместо kubectl вы вводили только одну букву: k.

1. Для этого нам необходимо выполнить следующую команду:

kubectl completion bash > kub.sh

Затем мы заходим в полученный файл и видоизменяем последние строки:

if [[ $(type -t compopt) = "builtin" ]]; then
    complete -o default -F __start_kubectl kubectl
else
    complete -o default -o nospace -F __start_kubectl kubectl
fi

alias k=kubectl

if [[ $(type -t compopt) = "builtin" ]]; then
    complete -o default -F __start_kubectl kubectl
    complete -o default -F __start_kubectl k
else
    complete -o default -o nospace -F __start_kubectl kubectl
    complete -o default -o nospace -F __start_kubectl k
fi

2. Вписываем следующую строку в своём ~/.bashrc:

source ~/kub.sh

(Другой вариант - просто перенести файл kub.sh в /etc/profile.d, если у вас есть такие права.)

3. Перезапустить bash-оболочку

Готово, теперь автодополнение команд: подстановка имён подов и пр. работает, если вы ввели всего одну букву k вместо семи kubectl.

Хитросплетённые команды, о существовании которых нужно знать и периодически подглядывать в них, если они вдруг становятся актуальны, а вы их не помните

Иногда у нас в одной директории находится очень много файлов и прошерстить их все и сразу командой типа grep "something" ./* не представляется возможным.
В такие моменты баш пишет вам что-то вроде:

bash: /usr/bin/grep: Argument list too long

Избежать этого можно с использованием опций крайне полезной команды find, например так:

find . -type f -exec grep "something" {} +

Соответственно в grep можно вписывать любые свои флаги, например -l - выводить только имена файлов без содержимого.

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

find . -type f -newermt '2024-03-04 17:25:00' ! -newermt '2024-03-04 17:30:00' \
 -exec grep -l "my-awesome-search" {} +

сперва найдёт все файлы, которые изменялись в промежутке с 17:25:00 до 17:30:00 указанной даты, а затем уже применит к ним grep.

Примечание: можно указывать только дату. Подробнее про манипуляции со временем вы можете посмотреть, например, здесь: dmosk.ru

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

Раздел маленьких бонусов.

В комментариях подсказали классный приём: использование символа "^".

Он очень хорошо работает в тех случаях, когда вам нужно применить предыдущую команду, но видоизменив её по следующему принципу:
^старое_значение^новое_значение
Оболочка ищет в последней команде подстроку "старое_значение" и заменяет его на "новое_значение", после чего исполняет новую команду.
Это может быть полезно как в тех случаях, когда вы совершили опечатку и вам нужно поменять одно слово в длинной команде, так и в случаях, когда команду нужно изменить незначительно. Классический пример, если после команды:

sudo systemctl restart postgres_exporter.service

Вы напишите:
^restart^status^
то будет исполнена команда:

sudo systemctl status postgres_exporter.service

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

Ещё один маленький бонус - пример синтеза лучших качеств от GUI и CLI:

sudo apt install flameshot

which flameshot

Выводы

1. Hotkeys сильно упрощают работу
   Исследуйте то окружение, которое вы используете. Оцените можно ли выполнять рутинные операции быстрее и проще.
   На мой взгляд лучше всякий раз осмысливать: "Как я могу сделать это быстрее?" и понемногу включать новые приёмы в свою работу, т. е. относиться к рутинным процессам как к некой практике осознанности или медитации.
   Это позволит потихоньку непрерывно совершенствоваться в скорости работы и получать всё больше удовольствия от процесса.

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

3. Обсудите с командой как можно сократить написание особенно длинных команд и операций с помощью алиасов или переменных.
   Если есть такая возможность - создайте общий .bash_aliases или .bash_profile, куда будут занесены все наиболее часто используемые переменные и иные сокращения команд.
   Это можно использовать в том числе как дополнительный инструмент для адаптации новых сотрудников, и им не придётся выписывать себе куда-то кучу заметок по тому где и что находится.