В прошлой статье я вам рассказал, но, а сегодня пришло время рассказать о том, как составить семантическое ядро сайта при помощи специальных программ и серверов.
Наступает лето и как-то все труднее и тяжелее становиться вести блог, вот и результат статьи выходят редко что вас наверняка не радует. Не правда ли?
Честно сказать дело вовсе не в летней поре, а в моей «глупости» создания блога на начальном этапе. В общем, я при создании блога отталкивался от своих мыслей, а не от запросов пользователей. В общем, получилось так, что я сам себе отвечал на вопросы, смешно.
В одном из прошлых своих постов, я уже, как то писал для чего нужно СЯ сайту и что это такое, где раскрыл основу основ его создания, пора бы, наверное, и к практике создания семантического ядра перейти.
как создать семантическое ядро для сайта
В прошлой статье я в основном рассказывал теорию, но как показывает практика не всегда все пользователи понимают такой материал, так что представляю пошаговую инструкцию, которую можно взять за основу и сделать своё семантическое ядро без особых усилий. Да именно за основу, так как прогресс не стоит на месте и, возможно, уже есть более продвинутые способы создания ядра для сайта.
Ищем конкурентов для составления семантического ядра сайта
Итак, первым делом мы должны определиться, про что и о чём будет наш будущий сайт. Я возьму за основу тему «экология окружающей природы» и подберу к ней ключевые слова. Для определения основных ключей я возьму сайт конкурента находящейся на первых местах и Google.
Как вы понимаете я возьму за основу первые три сайта в выдаче Яндекс.
сезоны-года.рф
zeleneet.com
biofile.ru
Отбираем запросы конкурентов - автоматически
На этом шаге нам хорошо подойдёт любой сайт, который может автоматически определить запросы сайта, подходящие для его продвижения в топ. Я предпочитаю использовать , какой вы предпочтёте сервер - это сугубо ваше мнение, о котором вы можете написать мне в комментариях и обсудить.
Добавляем нашего донора, а не наш сайт!
Как вы уже догадались я взял один из трёх сайтов, - вы же должны взять несколько. Жмём далее…
Как видите, я отобрал только первые 10 запросов для наглядного примера. Вы должны собрать как можно больше ключевых слов также не поленитесь подумать, как вы спросили у гугла, чтоб найти ответ на ваш вопрос, которые собираетесь размещать в интернете на своём блоге или сайте. Переходим к следующему этапу формирования семантического ядра своими руками.
Как вы уже поняли вам осталось только экспортировать базу ключевых слов и перейти к следующему шагу на пути создания семантического ядра сайта, который вы сделаете самостоятельно. Не забываете проставить галочки на ключевых словах, которые пытаетесь сохранить в файле exel.
Отбираем НЧ СЧ и ВЧ запросы
На этом этапе нам поможет сервер, осторожно партнерская ссылка, зарегистрироваться в rookee.ru. Переходим на него и создаём новую рекламную кампанию используя сайт нашего конкурента.
Добавляем сайт и следуем пошаговой инструкции интернет ресурса.
Теперь нужно немного подождать, чтоб робот отсканировал сайт и дал вам наиболее интересные запросы, которые вы также можете применить впоследствии. Вот мой результат.
Как видите, система нашла 299 запроса, но они меня не интересуют и я просто возьму их удалю и добавлю те 10, которые мне дал seopult на первом этапе. Кстати, один запрос должен оставаться, иначе не сможете все удалить.
У меня после удаления получилось так. Когда я добавлю основную базу запросов, я этот ключ удалю, чтоб он мне не мешал, так как он для меня не актуален. Теперь добавляем запросы, которые получили ранее.
Теперь нам нужно перейти в папку «запросы» и немного подождать, когда запросы просканирует поисковый робот. У меня в итоге вышло так, что все слова оказались НК (низкоконкурентными), которые мне вполне подходят для создания сайта и привлечения первых читателей на блог.
Если у вас есть слова со значением ВК (высокая конкуренция) или СК (средняя конкуренция), то на первом этапе формирования ядра вам следует от них отказаться и выбрать только низкую конкуренцию.
Экспортируем слова и переходим к следующему завершающему шагу. Так как у меня все слова по низкой конкуренции я ничего не удалял, у вас, возможно, другая ситуация. Но я вас убедительно прошу удалить средне и высоко конкурентные запросы, так как это лишние ваши затраты.
Составляем семантическое ядро для сайта
Для завершающего этапа нам понадобится программа Key Collector,я буду использовать её бесплатный прототип, который вы легко можете найти в интернете. Название этой программы я, пожалуй, оставлю вам в виде домашнего задания. Итак, открываем программу и вписываем свой найденные ключи, у меня их пока 9 штук.
Как мы видим, что из 9 запросов нам лучше писать про прибор для измерения влажности воздуха. Это пример с одним ключевым словом, которое актуально под НЧ запрос на указанную тематику.
Не забываете, что программа способна также подобрать 1 тыс. слов по основному запросу с его словоформами, для этого просто впишите слова в красную вкладку «пакетный сбор слов из Яндекс worstat».
После того как вы отберёте максимальное количество релевантных слов не забудьте их отсортировать по значимости начиная с меньшего. Старайтесь также делать хорошую перелинковку вашей статье, - это вызовет улучшение поведенческих фактов на вашем ресурсе.
Ну вот и все, что-то я затянул с работой. А вы как делаете СЯ для своего интернет-магазина? напишите мне об этом в комментариях.
P.S. Вы также можете получать мои новые статьи на почту просто подписавшись на rss рассылку и узнавать о моих секретах и методах первыми. А вы, как составляете семантическое ядро сайта? Напишите, мне о своем способе в комментариях, подискутируем.
Семантическое ядро — довольно избитая тема, не так ли? Сегодня мы вместе это исправим, собрав семантику в этом уроке!
Не верите? - посмотрите сами - достаточно просто вбить в Яндекс или Гугл фразу семантическое ядро сайта. Думаю, что сегодня я исправлю эту досадную ошибку.
А ведь и в самом деле, какая она для вас - идеальная семантика ? Можно подумать, что за глупый вопрос, но на самом деле он совсем даже неглуп, просто большинство web-мастеров и владельцев сайтов свято верят, что умеют составлять семантические ядра и в то, что со всем этим справится любой школьник, да еще и сами пытаются научить других… Но на самом деле все намного сложней. Однажды у меня спросили — что стоит делать вначале? — сам сайт и контент или сем ядро , причем спросил человек, который далеко не считает себя новичком в сео. Вот данный вопрос и дал мне понять всю сложность и неоднозначность данной проблемы.
Семантическое ядро — основа основ — тот самый первый шажок, который стоит перед и запуском любой рекламной кампании в интернете. Наряду с этим — семантика сайта наиболее муторный процесс, который потребует немало времени, зато с лихвой окупится в любом случае.
Ну что же… Давайте создадим его
вместе!
Небольшое предисловие
Для создания семантического поля сайта нам понадобится одна-единственная программа — Key Collector . На примере Коллектора я разберу пример сбора небольшой сем группы. Помимо платной программы, есть и бесплатные аналоги вроде СловоЕб и других.
Семантика собирается в несколько базовых этапов, среди которых следует выделить:
- мозговой штурм - анализ базовых фраз и подготовка парсинга
- парсинг - расширение базовой семантики на основе Вордстат и других источников
- отсев - отсев после парсинга
- анализ - анализ частотности, сезонности, конкуренции и других важных показателей
- доработка - групировка, разделение коммерческих и информационных фраз ядра
О наиболее важных этапах сбора и пойдет речь ниже!
ВИДЕО - составление семантического ядра по конкурентам
Мозговой штурм при создании семантического ядра — напрягаем мозги
На данном этапе надо в уме произвести подбор семантического ядра сайта и придумать как можно больше фраз под нашу тематику. Итак, запускаем кей коллектор и выбираем парсинг Wordstat , как это показано на скриншоте:
Перед нами открывается маленькое окошко, где необходимо ввести максимум фраз по нашей тематике. Как я уже говорил, в данной статье мы создадим пример набор фраз для этого блога , поэтому фразы могут быть следующими:
- seo блог
- сео блог
- блог про сео
- блог про seo
- продвижение
- продвижение проекта
- раскрутка
- раскрутка
- продвижение блогов
- продвижение блога
- раскрутка блогов
- раскрутка блога
- продвижение статьями
- статейное продвижение
- miralinks
- работа в sape
- покупка ссылок
- закупка ссылок
- оптимизация
- оптимизация страницы
- внутренняя оптимизация
- самостоятельная раскрутка
- как раскрутить ресурс
- как раскрутить свой сайт
- как раскрутить сайт самому
- как раскрутить сайт самостоятельно
- самостоятельная раскрутка
- бесплатная раскрутка
- бесплатное продвижение
- поисковая оптимизация
- как продвинуть сайт в яндексе
- как раскрутить сайт в яндексе
- продвижение под яндекс
- продвижение под гугл
- раскрутка в гугл
- индексация
- ускорение индексации
- выбор донора сайту
- отсев доноров
- раскрутка постовыми
- использование постовых
- раскрутка блогами
- алгоритм яндекса
- апдейт тиц
- апдейт поисковой базы
- апдейт яндекса
- ссылки навсегда
- вечные ссылки
- аренда ссылок
- арендованные ссылке
- ссылки с помесячной оплатой
- составление семантического ядра
- секреты раскрутки
- секреты раскрутки
- тайны seo
- тайны оптимизации
Думаю, достаточно, и так список с пол страницы;) В общем, идея в том, что на первом этапе вам необходимо проанализировать по максимуму свою отрасль и выбрать как можно больше фраз, отражающих тематику сайта. Хотя, если вы что-либо упустили на этом этапе — не отчаивайтесь — упущенные словосочетания обязательно всплывут на следующих этапах , просто придется делать много лишней работы, но ничего страшного. Берем наш список и копируем в key collector. Далее, нажимаем на кнопку — Парсить с Яндекс.Wordstat :
Парсинг может занять довольно продолжительное время, поэтому следует запастись терпением. Семантическое ядро обычно собирается 3-5 дней и первый день у вас уйдет на подготовку базового семантического ядра и парсинг.
О том, как работать с ресурсом , как подобрать ключевые слова я писал подробную инструкцию. А можно узнать о продвижении сайта по НЧ запросам.
Дополнительно скажу, что вместо мозгового штурма мы можем использовать уже готовую семантику конкурентов при помощи одного из специализированных сервисов, например — SpyWords. В интерфейсе данного сервиса мы просто вводим необходимое нам ключевое слово и видим основных конкурентов, которые присутствуют по этому словосочетанию в ТОП. Более того - семантика сайта любого конкурента может быть полностью выгружена при помощи этого сервиса.
Далее, мы можем выбрать любого из них и вытащить его запросы, которую останется отсеять от мусора и использовать как базовую семантику для дальнейшего парсинга. Либо мы можем поступить еще проще и использовать .
Чистка семантики
Как только, парсинг вордстата полностью прекратится — пришло время отсеять семантическое ядро . Данный этап очень важен, поэтому отнеситесь к нему с должным вниманием.
Итак, у меня парсинг закончился, но словосочетаний получилось ОЧЕНЬ много , а следовательно, отсев слов может отнять у нас лишнее время. Поэтому, перед тем как перейти к определению частотности, следует произвести первичную чистку слов. Сделаем мы это в несколько этапов:
1. Отфильтруем запросы с очень низкими частотностями
Для этого наживаем на символ сортировки по частотности, и начинаем отчищать все запросы, у которых частотности ниже 30:
Думаю, что с данным пунктом вы сможете без труда справиться.
2. Уберем не подходящие по смыслу запросы
Существуют такие запросы, которые имеют достаточную частотность и низкую конкуренцию, но они совершенно не подходят под нашу тематику . Такие ключи необходимо удалить перед проверкой точных вхождений ключа, т.к. проверка может отнять очень много времени. Удалять такие ключи мы будем вручную. Итак, для моего блога лишними оказались:
курсы поисковой оптимизации продам раскрученный сайт
Анализ семантического ядра
На данном этапе, нам необходимо определить точные частотности наших ключей, для чего вам необходимо нажать на символ лупы, как это показано на изображении:
Процесс довольно долгий, поэтому можете пойти и приготовить себе чай)
Когда проверка прошла успешно — необходимо продолжить чистку нашего ядра.
Предлагаю вам удалить все ключи с частотностью меньше 10 запросов. Также, для своего блога я удалю все запросы, имеющие значения выше 1 000, так как продвигаться по таким запросам я пока что не планирую.
Экспорт и группировка семантического ядра
Не стоит думать, что данный этап окажется последним. Совсем нет! Сейчас нам необходимо перенести получившуюся группу в Exel для максимальной наглядности. Далее мы будем сортировать по страницам и тогда увидим многие недочеты, исправлением которых и займемся.
Экспортируется семантика сайта в Exel совсем нетрудно. Для этого просто необходимо нажать на соответствующий символ, как это показано на изображении:
После вставки в Exel, мы увидим следующую картину:
Столбцы, помеченные красным цветом необходимо удалить. Затем создаем еще одну таблицу в Exel, где будет содержаться финальное семантическое ядро.
В новой таблице будет 3 столбца: URL страницы , ключевое словосочетание и его частотность . В качестве URL выбираем или уже существующую страницу или страницу, которая будет создана в перспективе. Для начала, давайте выберем ключи для главной страницы моего блога:
После всех манипуляций, мы видим следующую картину. И сразу напрашивается несколько выводов:
- такие частотные запросы, как должны иметь намного больший хвост из менее частотных фраз, чем мы видим
- сео новости
- всплыл новый ключ, который мы не учли ранее — статьи сео . Необходимо проанализировать этот ключ
Как я уже говорил, ни один ключ от нас не спрячется. Следующим шагом для нас станет мозговой штурм этих трех фраз. После мозгового штурма повторяем все шаги начиная с самого первого пункта для этих ключей. Вам может все это показаться слишком долгим и нудным, но так оно и есть — составление семантического ядра — очень ответственная и кропотливая работа. Зато, грамотно составленное сем поле сильно поможет в продвижении сайта и способно сильно сэкономить ваш бюджет.
После всех проделанных операций, мы смогли получить новые ключи для главной страницы этого блога:
- лучший seo блог
- seo новости
- статьи seo
И некоторые другие. Думаю, что методика вам понятна.
После всех этих манипуляций мы увидим, какие страницы нашего проекта необходимо изменить (), а какие новые страницы необходимо добавить. Большинство ключей, найденных нами (с частотностью до 100, а иногда и намного выше) можно без труда продвинуть одними .
Финальный отсев
В принципе, семантическое ядро практически готово, но есть еще один довольно важный пункт, который поможет нам заметно улучшить нашу сем группу. Для этого нам понадобится Seopult.
*На самом деле тут можно использовать любой из аналогичных сервисов, позволяющих узнать конкуренцию по ключевым словам, например, Мутаген!
Итак, создаем еще одну таблицу в Exel и копируем туда только названия ключей (средний столбец). Чтобы не тратить много времени, я скопирую только ключи для главной страницы своего блога:
Затем проверяем стоимость получения одного перехода по нашим ключевым словам:
Стоимость перехода по некоторым словосочетаниям превысила 5 рублей. Такие фразы необходимо исключить из нашего ядра.
Возможно, ваши предпочтения окажутся несколько иными, тогда вы можете исключать и менее дорогие фразы или наоборот. В своем случае, я удалил 7 фраз .
Полезная информация!
по составлению семантического ядра, с упором на отсев наиболее низкоконкурентных ключевых слов.
Если у вас свой интернет-магазин — прочитайте , где описано, как может быть использовано семантическое ядро.
Кластеризация семантического ядра
Уверен, что ранее тебе уже доводилось слышать это слово применительно к поисковому продвижению. Давай разберемся, что же это за зверь такой и зачем он нужен при продвижении сайта.
Классическая модель поискового продвижения выглядит следующим образом:
- Подбор и анализ поисковых запросов
- Группировка запросов по страницам сайта (создание посадочных страниц)
- Подготовка seo текстов для посадочных страниц на основе группы запросов для этих страниц
Для облегчения и улучшения второго этапа в списке выше и служит кластеризация. По сути своей - кластеризация это программный метод, служащий для упрощения этого этапа при работе с большими семантиками, но тут не все так просто, как может показаться на первый взгляд.
Для лучшего понимания теории кластеризации следует сделать небольшой экскурс в историю SEO:
Еще буквально несколько лет назад, когда термин кластеризация не выглядывал из-за каждого угла - сеошники, в подавляющем большинстве случаев, группировали семантику руками. Но при группировке огромных семантик в 1000, 10 000 и даже 100 000 запросов данная процедура превращалась в настоящую каторгу для обычного человека. И тогда повсеместно начали использовать методику группировки по семантике (и сегодня очень многие используют этот подход). Методика группировки по семантике подразумевает объединение в одну группу запросов, имеющих семантическое родство. Как пример - запросы “купить стиральную машинку” и “купить стиральную машинку до 10 000” объединялись в одну группу. И все бы хорошо, но данный метод содержит в себе целый ряд критических проблем и для их понимания необходимо ввести новый термин в наше повествование, а именно – “интент запроса ”.
Проще всего описать данный термин можно как потребность пользователя, его желание. Интент является ни чем иным, как желанием пользователя, вводящего поисковый запрос.
Основа группировки семантики - собрать в одну группу запросы, имеющие один и тот же интент, либо максимально близкие интенты, причем тут всплывает сразу 2 интересных особенности, а именно:
- Один и тот же интент могут иметь несколько запросов не имеющих какой-либо семантической близости, например – “обслуживание автомобиля” и “записаться на ТО”
- Запросы, имеющие абсолютную семантическую близость могут содержать в себе кардинально разные интенты, например, хрестоматийная ситуация – “мобильник” и “мобильники”. В одном случае пользователь хочет купить телефон, а в другом посмотреть фильм
Так вот, группировка семантики по семантическому соответствию никак не учитывает интенты запросов. И группы, составленные таким образом не позволят написать текст, который попадет в ТОП. Во временя ручной группировки для устранения этого недоразумения ребята с профессией «подручный SEO специалиста» анализировали выдачу руками.
Суть кластеризации – сравнение сформировавшейся выдачи поисковой системы в поисках закономерностей. Из этого определения сразу следует сделать для себя заметку, что сама кластеризация не является истиной в последней инстанции, ведь сформировавшаяся выдача может и не раскрывать полностью интент (в базе Яндекс может просто не быть сайта, который правильно объединил запросы в группу).
Механика кластеризации проста и выглядит следующим образом:
- Система поочередно вводит все поданные ей запросы в поисковую выдачу и запоминает результаты из ТОП
- После поочередного ввода запросов и сохранения результатов, система ищет пересечения в выдаче. Если один и тот же сайт одним и тем же документом (страница сайта) находится в ТОП сразу по нескольким запросам, то эти запросы теоретически можно объединить в одну группу
- Становится актуальным такой параметр, как сила группировки, который говорит системе, сколько именно должно быть пересечений, чтобы запросы можно было добавить в одну группу. К примеру, сила группировки 2 означает, что в выдаче по 2-м разным запросам должно присутствовать не менее двух пересечений. Говоря еще проще – минимум две страницы двух разных сайтов должны присутствовать одновременно в ТОП по одному и другому запросу. Пример ниже.
- При группировках больших семантики становится актуальна логика связей между запросами, на основе которой выделяют 3 базовых вида кластеризации: soft, middle и hard. О видах кластеризации мы еще поговорим в следующих записях этого дневника
Разработка ядра по праву считается задачей не из легких, но написать простейшее ядро может каждый. Чтобы прикоснуться к магии кернел-хакинга, нужно лишь соблюсти некоторые условности и совладать с ассемблером. В этой статье мы на пальцах разберем, как это сделать.
Это перевод двух статей Арджуна Сридхарана:
Привет, мир! Давай напишем ядро, которое будет загружаться через GRUB на системах, совместимых с x86. Наше первое ядро будет показывать сообщение на экране и на этом останавливаться.
Как загружаются x86-машины
Прежде чем думать о том, как писать ядро, давай посмотрим, как компьютер загружается и передает управление ядру. Большинство регистров процессора x86 имеют определенные значения после загрузки. Регистр - указатель на инструкцию (EIP) содержит адрес инструкции, которая будет исполнена процессором. Его захардкоженное значение - это 0xFFFFFFF0. То есть x86-й процессор всегда будет начинать исполнение с физического адреса 0xFFFFFFF0. Это последние 16 байт 32-разрядного адресного пространства. Этот адрес называется «вектор сброса» (reset vector).
В карте памяти, которая содержится в чипсете, прописано, что адрес 0xFFFFFFF0 ссылается на определенную часть BIOS, а не на оперативную память. Однако BIOS копирует себя в оперативку для более быстрого доступа - этот процесс называется «шедоуинг» (shadowing), создание теневой копии. Так что адрес 0xFFFFFFF0 будет содержать только инструкцию перехода к тому месту в памяти, куда BIOS скопировала себя.
Итак, BIOS начинает исполняться. Сначала она ищет устройства, с которых можно загружаться в том порядке, который задан в настройках. Она проверяет носители на наличие «волшебного числа», которое отличает загрузочные диски от обычных: если байты 511 и 512 в первом секторе равны 0xAA55, значит, диск загрузочный.
Как только BIOS найдет загрузочное устройство, она скопирует содержимое первого сектора в оперативную память, начиная с адреса 0x7C00, а затем переведет исполнение на этот адрес и начнет исполнение того кода, который только что загрузила. Вот этот код и называется загрузчиком (bootloader).
Загрузчик загружает ядро по физическому адресу 0x100000. Именно он и используется большинством популярных ядер для x86.
Все процессоры, совместимые с x86, начинают свою работу в примитивном 16-разрядном режиме, которые называют «реальным режимом» (real mode). Загрузчик GRUB переключает процессор в 32-разрядный защищенный режим (protected mode), переводя нижний бит регистра CR0 в единицу. Поэтому ядро начинает загружаться уже в 32-битном защищенном режиме.
Заметь, что GRUB в случае с ядрами Linux выбирает соответствующий протокол загрузки и загружает ядро в реальном режиме. Ядра Linux сами переключаются в защищенный режим.
Что нам понадобится
- Компьютер, совместимый с x86 (очевидно),
- Linux,
- ассемблер NASM,
- ld (GNU Linker),
- GRUB.
Ты можешь найти исходный код того, что у нас должно получиться, .
Входная точка на ассемблере
Нам бы, конечно, хотелось написать все на C, но совсем избежать использования ассемблера не получится. Мы напишем на ассемблере x86 небольшой файл, который станет стартовой точкой для нашего ядра. Все, что будет делать ассемблерный код, - это вызывать внешнюю функцию, которую мы напишем на C, а потом останавливать выполнение программы.
Как сделать так, чтобы ассемблерный код стал стартовой точкой для нашего ядра? Мы используем скрипт для компоновщика (linker), который линкует объектные файлы и создает финальный исполняемый файл ядра (подробнее объясню чуть ниже). В этом скрипте мы напрямую укажем, что хотим, чтобы наш бинарный файл загружался по адресу 0x100000. Это адрес, как я уже писал, по которому загрузчик ожидает увидеть входную точку в ядро.
Вот код на ассемблере.
kernel.asm
bits 32 section . text global start extern kmain start : mov esp , stack_space call kmain section . bss resb 8192 stack_space : |
Первая инструкция bits 32 - это не ассемблер x86, а директива NASM, сообщающая, что нужно генерировать код для процессора, который будет работать в 32-разрядном режиме. Для нашего примера это не обязательно, но указывать это явно - хорошая практика.
Вторая строка начинает текстовую секцию, также известную как секция кода. Сюда пойдет весь наш код.
global - это еще одна директива NASM, она объявляет символы из нашего кода глобальными. Это позволит компоновщику найти символ start , который и служит нашей точкой входа.
kmain - это функция, которая будет определена в нашем файле kernel.c . extern объявляет, что функция декларирована где-то еще.
Далее идет функция start , которая вызывает kmain и останавливает процессор инструкцией hlt . Прерывания могут будить процессор после hlt , так что сначала мы отключаем прерывания инструкцией cli (clear interrupts).
В идеале мы должны выделить какое-то количество памяти под стек и направить на нее указатель стека (esp). GRUB, кажется, это и так делает за нас, и на этот момент указатель стека уже задан. Однако на всякий случай выделим немного памяти в секции BSS и направим указатель стека на ее начало. Мы используем инструкцию resb - она резервирует память, заданную в байтах. Затем оставляется метка, указывающая на край зарезервированного куска памяти. Прямо перед вызовом kmain указатель стека (esp) направляется на эту область инструкцией mov .
Ядро на C
В файле kernel.asm мы вызвали функцию kmain() . Так что в коде на C исполнение начнется с нее.
kernel.c
void kmain (void ) const char * str = "my first kernel" ; char * vidptr = (char * ) 0xb8000 ; unsigned int i = 0 ; unsigned int j = 0 ; while (j < 80 * 25 * 2 ) { vidptr [ j ] = " " ; vidptr [ j + 1 ] = 0x07 ; j = j + 2 ; j = 0 ; while (str [ j ] != "\0" ) { vidptr [ i ] = str [ j ] ; vidptr [ i + 1 ] = 0x07 ; i = i + 2 ; return ; |
Все, что будет делать наше ядро, - очищать экран и выводить строку my first kernel.
Первым делом мы создаем указатель vidptr, который указывает на адрес 0xb8000. В защищенном режиме это начало видеопамяти. Текстовая экранная память - это просто часть адресного пространства. Под экранный ввод-вывод выделен участок памяти, который начинается с адреса 0xb8000, - в него помещается 25 строк по 80 символов ASCII.
Каждый символ в текстовой памяти представлен 16 битами (2 байта), а не 8 битами (1 байтом), к которым мы привыкли. Первый байт - это код символа в ASCII, а второй байт - это attribute-byte . Это определение формата символа, в том числе - его цвет.
Чтобы вывести символ s зеленым по черному, нам нужно поместить s в первый байт видеопамяти, а значение 0x02 - во второй байт. 0 здесь означает черный фон, а 2 - зеленый цвет. Мы будем использовать светло-серый цвет, его код - 0x07.
В первом цикле while программа заполняет пустыми символами с атрибутом 0x07 все 25 строк по 80 символов. Это очистит экран.
Во втором цикле while символы строки my first kernel, оканчивающейся нулевым символом, записываются в видеопамять и каждый символ получает attribute-byte, равный 0x07. Это должно привести к выводу строки.
Компоновка
Теперь мы должны собрать kernel.asm в объектный файл с помощью NASM, а затем при помощи GCC скомпилировать kernel.c в другой объектный файл. Наша задача - слинковать эти объекты в исполняемое ядро, пригодное к загрузке. Для этого потребуется написать скрипт для компоновщика (ld), который мы передадим ему в качестве аргумента.
link.ld
OUTPUT_FORMAT (elf32 - i386 ) ENTRY (start ) SECTIONS 0x100000 ; Text : { * (. text ) } Data : { * (. data ) } Bss : { * (. bss ) } |
Здесь мы сначала задаем формат (OUTPUT_FORMAT) нашего исполняемого файла как 32-битный ELF (Executable and Linkable Format), стандартный бинарный формат для Unix-образных систем для архитектуры x86.
ENTRY принимает один аргумент. Он задает название символа, который будет служить входной точкой исполняемого файла.
SECTIONS - это самая важная для нас часть. Здесь мы определяем раскладку нашего исполняемого файла. Мы можем определить, как разные секции будут объединены и куда каждая из них будет помещена.
В фигурных скобках, которые идут за выражением SECTIONS , точка означает счетчик позиции (location counter). Он автоматически инициализируется значением 0x0 в начале блока SECTIONS , но его можно менять, назначая новое значение.
Ранее я уже писал, что код ядра должен начинаться по адресу 0x100000. Именно поэтому мы и присваиваем счетчику позиции значение 0x100000.
Взгляни на строку.text: { *(.text) } . Звездочкой здесь задается маска, под которую подходит любое название файла. Соответственно, выражение *(.text) означает все входные секции.text во всех входных файлах.
В результате компоновщик сольет все текстовые секции всех объектных файлов в текстовую секцию исполняемого файла и разместит по адресу, указанному в счетчике позиции. Секция кода нашего исполняемого файла будет начинаться по адресу 0x100000.
После того как компоновщик выдаст текстовую секцию, значение счетчика позиции будет 0x1000000 плюс размер текстовой секции. Точно так же секции data и bss будут слиты и помещены по адресу, который задан счетчиком позиции.
GRUB и мультизагрузка
Теперь все наши файлы готовы к сборке ядра. Но поскольку мы будем загружать ядро при помощи GRUB , остается еще один шаг.
Существует стандарт для загрузки разных ядер x86 с помощью бутлоадера. Это называется « спецификация мультибута ». GRUB будет загружать только те ядра, которые ей соответствуют.
В соответствии с этой спецификацией ядро может содержать заголовок (Multiboot header) в первых 8 килобайтах. В этом заголовке должно быть прописано три поля:
- magic - содержит «волшебное» число 0x1BADB002, по которому идентифицируется заголовок;
- flags - это поле для нас не важно, можно оставить ноль;
- checksum - контрольная сумма, должна дать ноль, если прибавить ее к полям magic и flags .
Наш файл kernel.asm теперь будет выглядеть следующим образом.
kernel.asm
bits 32 section . text ; multiboot spec align 4 dd 0x1BADB002 ; magic dd 0x00 ; flags dd - (0x1BADB002 + 0x00 ) ; checksum global start extern kmain start : mov esp , stack_space call kmain section . bss resb 8192 stack_space : |
Инструкция dd задает двойное слово размером 4 байта.
Собираем ядро
Итак, все готово для того, чтобы создать объектный файл из kernel.asm и kernel.c и слинковать их с применением нашего скрипта. Пишем в консоли:
Параметр -c указывает на то, что файл после компиляции не нужно линковать. Мы это сделаем сами:
$ ld - m elf_i386 - T link . ld - o kernel kasm . o kc . o |
Эта команда запустит компоновщик с нашим скриптом и сгенерирует исполняемый файл под названием kernel .
Хакингом ядра лучше всего заниматься в виртуалке. Чтобы запустить ядро в QEMU вместо GRUB, используй команду qemu-system-i386 -kernel kernel .
Настраиваем GRUB и запускаем ядро
GRUB требует, чтобы название файла с ядром следовало конвенции kernel-<версия> . Так что переименовываем файл - я назову свой kernel-701 .
Теперь кладем ядро в каталог /boot . На это понадобятся привилегии суперпользователя.
В конфигурационный файл GRUB grub.cfg нужно будет добавить что-то в таком роде:
Пишем ядро с поддержкой клавиатуры и экрана
Мы закончили работу над минимальным ядром, которое загружается через GRUB, работает в защищенном режиме и выводит на экран одну строку. Настала пора расширить его и добавить драйвер клавиатуры, который будет читать символы с клавиатуры и выводить их на экран.
Полный исходный код ты можешь найти в репозитории автора на GitHub .
Мы будем общаться с устройствами ввода-вывода через порты ввода-вывода. По сути, они просто адреса на шине ввода-вывода. Для операций чтения и записи в них существуют специальные процессорные инструкции.
Работа с портами: чтение и вывод
read_port : mov edx , [ esp + 4 ] in al , dx write_port : mov edx , [ esp + 4 ] mov al , [ esp + 4 + 4 ] out dx , al |
Доступ к портам ввода-вывода осуществляется при помощи инструкций in и out , входящих в набор x86.
В read_port номер порта передается в качестве аргумента. Когда компилятор вызывает функцию, он кладет все аргументы в стек. Аргумент копируется в регистр edx при помощи указателя на стек. Регистр dx - это нижние 16 бит регистра edx . Инструкция in здесь читает порт, номер которого задан в dx , и кладет результат в al . Регистр al - это нижние 8 бит регистра eax . Возможно, ты помнишь из институтского курса, что значения, возвращаемые функциями, передаются через регистр eax . Таким образом, read_port позволяет нам читать из портов ввода-вывода.
Функция write_port работает схожим образом. Мы принимаем два аргумента: номер порта и данные, которые будут записаны. Инструкция out пишет данные в порт.
Прерывания
Теперь, прежде чем мы вернемся к написанию драйвера, нам нужно понять, как процессор узнает, что какое-то из устройств выполнило операцию.
Самое простое решение - это опрашивать устройства - непрерывно по кругу проверять их статус. Это по очевидным причинам неэффективно и непрактично. Поэтому здесь в игру вступают прерывания. Прерывание - это сигнал, посылаемый процессору устройством или программой, который означает, что произошло событие. Используя прерывания, мы можем избежать необходимости опрашивать устройства и будем реагировать только на интересующие нас события.
За прерывания в архитектуре x86 отвечает чип под названием Programmable Interrupt Controller (PIC). Он обрабатывает хардверные прерывания и направляет и превращает их в соответствующие системные прерывания.
Когда пользователь что-то делает с устройством, чипу PIC отправляется импульс, называемый запросом на прерывание (Interrupt Request, IRQ). PIC переводит полученное прерывание в системное прерывание и отправляет процессору сообщение о том, что пора прервать то, что он делает. Дальнейшая обработка прерываний - это задача ядра.
Без PIC нам бы пришлось опрашивать все устройства, присутствующие в системе, чтобы посмотреть, не произошло ли событие с участием какого-то из них.
Давай разберем, как это работает в случае с клавиатурой. Клавиатура висит на портах 0x60 и 0x64. Порт 0x60 отдает данные (когда нажата какая-то кнопка), а порт 0x64 передает статус. Однако нам нужно знать, когда конкретно читать эти порты.
Прерывания здесь приходятся как нельзя более кстати. Когда кнопка нажата, клавиатура отправляет PIC сигнал по линии прерываний IRQ1. PIС хранит значение offset , сохраненное во время его инициализации. Он добавляет номер входной линии к этому отступу, чтобы сформировать вектор прерывания. Затем процессор ищет структуру данных, называемую «таблица векторов прерываний» (Interrupt Descriptor Table, IDT), чтобы дать функции - обработчику прерывания адрес, соответствующий его номеру.
Затем код по этому адресу исполняется и обрабатывает прерывание.
Задаем IDT
struct IDT_entry { unsigned short int offset_lowerbits ; unsigned short int selector ; unsigned char zero ; unsigned char type_attr ; unsigned short int offset_higherbits ; struct IDT_entry IDT [ IDT_SIZE ] ; void idt_init (void ) unsigned long keyboard_address ; unsigned long idt_address ; unsigned long idt_ptr [ 2 ] ; keyboard_address = (unsigned long ) keyboard_handler ; IDT [ 0x21 ] . offset_lowerbits = keyboard_address & 0xffff ; IDT [ 0x21 ] . selector = 0x08 ; /* KERNEL_CODE_SEGMENT_OFFSET */ IDT [ 0x21 ] . zero = 0 ; IDT [ 0x21 ] . type_attr = 0x8e ; /* INTERRUPT_GATE */ IDT [ 0x21 ] . offset_higherbits = (keyboard_address & 0xffff0000 ) >> 16 ; write_port (0x20 , 0x11 ) ; write_port (0xA0 , 0x11 ) ; write_port (0x21 , 0x20 ) ; write_port (0xA1 , 0x28 ) ; write_port (0x21 , 0x00 ) ; write_port (0xA1 , 0x00 ) ; write_port (0x21 , 0x01 ) ; write_port (0xA1 , 0x01 ) ; write_port (0x21 , 0xff ) ; write_port (0xA1 , 0xff ) ; idt_address = (unsigned long ) IDT ; idt_ptr [ 0 ] = (sizeof (struct IDT_entry ) * IDT_SIZE ) + ((idt_address & 0xffff ) << 16 ) ; idt_ptr [ 1 ] = idt_address >> 16 ; load_idt (idt_ptr ) ; } |
IDT - это массив, объединяющий структуры IDT_entry. Мы еще обсудим привязку клавиатурного прерывания к обработчику, а сейчас посмотрим, как работает PIC.
Современные системы x86 имеют два чипа PIC, у каждого восемь входных линий. Будем называть их PIC1 и PIC2. PIC1 получает от IRQ0 до IRQ7, а PIC2 - от IRQ8 до IRQ15. PIC1 использует порт 0x20 для команд и 0x21 для данных, а PIC2 - порт 0xA0 для команд и 0xA1 для данных.
Оба PIC инициализируются восьмибитными словами, которые называются «командные слова инициализации» (Initialization command words, ICW).
В защищенном режиме обоим PIC первым делом нужно отдать команду инициализации ICW1 (0x11). Она сообщает PIC, что нужно ждать еще трех инициализационных слов, которые придут на порт данных.
Эти команды передадут PIC:
- вектор отступа (ICW2),
- какие между PIC отношения master/slave (ICW3),
- дополнительную информацию об окружении (ICW4).
Вторая команда инициализации (ICW2) тоже шлется на вход каждого PIC. Она назначает offset , то есть значение, к которому мы добавляем номер линии, чтобы получить номер прерывания.
Данный цикл статей посвящён низкоуровневому программированию, то есть архитектуре компьютера, устройству операционных систем, программированию на языке ассемблера и смежным областям. Пока что написанием занимаются два хабраюзера - и . Для многих старшеклассников, студентов, да и профессиональных программистов эти темы оказываются весьма сложными при обучении. Существует много литературы и курсов, посвящённых низкоуровневому программированию, но по ним сложно составить полную и всеохватывающую картину. Сложно, прочитав одну-две книги по ассемблеру и операционным системам, хотя бы в общих чертах представить, как же на самом деле работает эта сложная система из железа, кремния и множества программ - компьютер.
Каждый решает проблему обучения по-своему. Кто-то читает много литературы, кто-то старается поскорее перейти к практике и разбираться по ходу дела, кто-то пытается объяснять друзьям всё, что сам изучает. А мы решили совместить эти подходы. Итак, в этом курсе статей мы будем шаг за шагом демонстрировать, как пишется простая операционная система. Статьи будут носить обзорный характер, то есть в них не будет исчерпывающих теоретических сведений, однако мы будем всегда стараться предоставить ссылки на хорошие теоретические материалы и ответить на все возникающие вопросы. Чёткого плана у нас нет, так что многие важные решения будут приниматься по ходу дела, с учётом ваших отзывов.
Возможно, мы умышленно будем заводить процесс разработки в тупик, чтобы позволить вам и себе полностью осознать все последствия неверно принятого решения, а также отточить на нем некоторые технические навыки. Так что не стоит воспринимать наши решения как единственно верные и слепо нам верить. Еще раз подчеркнём, что мы ожидаем от читателей активности в обсуждении статей, которая должна сильно влиять на общий процесс разработки и написания последующих статей. В идеале хотелось бы, чтобы со временем некоторые из читателей присоединились к разработке системы.
Мы будем предполагать, что читатель уже знаком с основами языков ассемблер и Си, а также элементарными понятиями архитектуры ЭВМ. То есть, мы не будем объяснять, что такое регистр или, скажем, оперативная память. Если вам не будет хватать знаний, вы всегда можете обратиться к дополнительной литературе. Краткий список литературы и ссылки на сайты с хорошими статьями есть в конце статьи. Также желательно уметь пользоваться Linux, так как все инструкции по компиляции будут приводиться именно для этой системы.
А теперь - ближе к делу. В оставшейся части статьи мы с вами напишем классическую программу «Hello World». Наш хеллоуворлд получится немного специфическим. Он будет запускаться не из какой-либо операционной системы, а напрямую, так сказать «на голом железе». Перед тем, как приступить непосредственно к написанию кода, давайте разберёмся, как же конкретно мы пытаемся это сделать. А для этого надо рассмотреть процесс загрузки компьютера.
Итак, берем свой любимый компьютер и нажимаем самую большую кнопочку на системном блоке. Видим веселую заставку, системный блок радостно пищит спикером и через какое-то время загружается операционная система. Как вы понимаете, операционная система хранится на жёстком диске, и вот тут возникает вопрос: а каким же волшебным образом операционная система загрузилась в ОЗУ и начала выполняться?
Знайте же: за это отвечает система, которая есть на любом компьютере, и имя ей - нет, не Windows, типун вам на язык - называется она BIOS. Расшифровывается ее название как Basic Input-Output System, то есть базовая система ввода-вывода. Находится BIOS на маленькой микросхемке на материнской плате и запускается сразу после нажатия большой кнопки ВКЛ. У BIOS три главных задачи:
- Обнаружить все подключенные устройства (процессор, клавиатуру, монитор, оперативную память, видеокарту, голову, руки, крылья, ноги и хвосты…) и проверить их на работоспособность. Отвечает за это программа POST (Power On Self Test – самотестирование при нажатии ВКЛ). Если жизненно важное железо не обнаружено, то никакой софт помочь не сможет, и на этом месте системный динамик пропищит что-нибудь зловещее и до ОС дело вообще не дойдет. Не будем о печальном, предположим, что у нас есть полностью рабочий компьютер, возрадуемся и перейдем к рассмотрению второй функции BIOS:
- Предоставление операционной системе базового набора функций для работы с железом. Например, через функции BIOS можно вывести текст на экране или считать данные с клавиатуры. Потому она и называется базовой системой ввода-вывода. Обычно операционная система получает доступ к этим функциям посредством прерываний.
- Запуск загрузчика операционной системы. При этом, как правило, считывается загрузочный сектор - первый сектор носителя информации (дискета, жесткий диск, компакт-диск, флэшка). Порядок опроса носителей можно задать в BIOS SETUP. В загрузочном секторе содержится программа, иногда называемая первичным загрузчиком. Грубо говоря, задача загрузчика - начать запуск операционной системы. Процесс загрузки операционной системы может быть весьма специфичен и сильно зависит от её особенностей. Поэтому первичный загрузчик пишется непосредственно разработчиками ОС и при установке записывается в загрузочный сектор. В момент запуска загрузчика процессор находится в реальном режиме.
На картинке изображена поверхность дискового накопителя. У дискеты 2 поверхности. На каждой поверхности есть кольцеобразные дорожки (треки). Каждый трек делится на маленькие дугообразные кусочки, называемые секторами. Так вот, исторически сложилось, что сектор дискеты имеет размер 512 байт. Самый первый сектор на диске, загрузочный сектор, читается BIOS"ом в нулевой сегмент памяти по смещению 0x7С00, и дальше по этому адресу передается управление. Начальный загрузчик обычно загружает в память не саму ОС, а другую программу-загрузчик, хранящуюся на диске, но по каким-то причинам (скорее всего, эта причина - размер) не влезающую в один сектор. А поскольку пока что роль нашей ОС выполняет банальный хеллоуворлд, наша главная цель - заставить компьютер поверить в существование нашей ОС, пусть даже и на одном секторе, и запустить её.
Как устроен загрузочный сектор? На PC единственное требование к загрузочному сектору - это содержание в двух его последних байтах значений 0x55 и 0xAA - сигнатуры загрузочного сектора. Итак, уже более-менее понятно, что нам нужно делать. Давайте же писать код! Приведённый код написан для ассемблера yasm .
section . text
use16
org 0x7C00 ; наша программа загружается по адресу 0x7C00
start:
mov ax , cs
mov ds , ax ; выбираем сегмент данных
mov si , message
cld ; направление для строковых команд
mov ah , 0x0E ; номер функции BIOS
mov bh , 0x00 ; страница видеопамяти
puts_loop:
lodsb ; загружаем очередной символ в al
test al , al ; нулевой символ означает конец строки
jz puts_loop_exit
int 0x10 ; вызываем функцию BIOS
jmp puts_loop
puts_loop_exit:
jmp $ ; вечный цикл
message:
db "Hello World!" , 0
finish:
times 0x1FE - finish+ start db 0
db 0x55 , 0xAA ; сигнатура загрузочного сектора
Эта короткая программа требует ряда важных пояснений. Строка org 0x7C00 нужна для того, чтобы ассемблер (имеется в виду программа, а не язык) правильно рассчитал адреса для меток и переменных (puts_loop, puts_loop_exit, message). Вот мы ему и сообщаем, что программа будет загружена в память по адресу 0x7C00.
В строках
mov ax , csпроисходит установка сегмента данных (ds) равным сегменту кода (cs), поскольку в нашей программе и данные, и код хранятся в одном сегменте.
mov ds , ax
Далее в цикле посимвольно выводится сообщение «Hello World!». Для этого используется функция 0x0E прерывания 0x10 . Она имеет следующие параметры:
AH = 0x0E (номер функции)
BH = номер видеостраницы (пока не заморачиваемся, указываем 0)
AL = ASCII-код символа
В строке « jmp $ » программа зависает. И правильно, незачем ей выполнять лишний код. Однако чтобы компьютер опять заработал, придется перезагрузиться.
В строке « times 0x1FE-finish+start db 0 » производится заполнение остатка кода программы (за исключением последних двух байт) нулями. Делается это для того, чтобы после компиляции в последних двух байтах программы оказалась сигнатура загрузочного сектора.
С кодом программы вроде разобрались, давайте теперь попробуем скомпилировать это счастье. Для компиляции нам понадобится, собственно говоря, ассемблер - выше упомянутый
Когда начинаешь читать пособия по продвижению сайта, всё всегда начинается с создания семантического ядра. Для новичков этот первый шаг – самый трудный. Кроме того, что не сразу становится понятно, что такое это семантическое ядро, ещё и не ясно, какую оно имеет цель и как его правильно создавать.
В этой статье мы расскажем о том, как правильно создавать семантическое ядро сайта. А также вы узнаете о том, что это такое и для чего его делают. На самом деле в понятии семантического ядра нет ничего сложного и трудного. Давайте разбираться.
Никто ещё не отвечал на вопрос о том, что такое семантическое ядро такими простыми словами, как сейчас это сделаем мы. Итак, семантическое ядро сайта - это список ключевых фраз, по которым он будет продвигаться. Всё! Весь смысл понятия в одном коротком ясном предложении. И не надо ничего мутить умными терминами.
Если капнуть в термин глубже, то семантика - это наука, которая занимается смысловым наполнением лексических единиц. Говоря простыми словами, семантика изучает смысл чего-либо. В SEO семантическое ядро даёт понять смысл всего сайта, его какого-либо раздела или отдельной взятой статьи. Это становится понятно поисковику, посетителю, всем разработчикам, которые будут работать с сайтом.
Семантическое ядро без преувеличения - это фундамент всего продвижения.
Как использовать семантическое ядро и для чего оно нужно
Функциями семантического ядра можно назвать следующие аспекты продвижения сайта:
- Самая главная задача семантического ядра - это понимание структуры сайта и его наполненности. Глядя на него, можно представить себе, какие разделы у сайта будут, и какие статьи будут в каждом разделе. И, таким образом, все недостатки и неудобства структуры сразу видны, и их можно устранить ещё на раннем этапе.
- Семантика задаёт вектор контента. Благодаря лучшему понимаю структуры сайта, можно подобрать наиболее релевантные и эффективные ключевые фразы.
- Семантическое ядро - это контент-план сайта на долгие годы вперёд. Каждый раз, когда нужно написать статьи, можно заглянуть туда и увидеть, какой контент планировался и в каком разделе сайта он должен быть.
- Если планируется платное продвижение сайта, например, за счёт контекстной рекламы, то благодаря семантическому ядру можно рассчитать стоимость продвижения.
Как сделать семантическое ядро
Для начала надо определиться, откуда вы будете брать ключевые фразы для ядра. Наиболее лучший для новичков источник - это сервис Яндекс WordPStat, который показывает то, сколько раз в месяц вводился тот или иной запрос в поиск Яндекс. У WordStat есть разнообразные полезные функции, например можно фильтровать запросы по регионам или устройствам, смотреть похожие запросы и многое другое. А самое главное, что он абсолютно бесплатный. Подробнее об этом .
Можно использовать и разнообразные платные программы, но новичкам лучше подойдёт именно WordStat, в виду его простоты. Кроме этого, он подойдёт не только для Рунета, где Яндекс преобладает. Если вы продвигаете сайт в пределах СНГ, то его можно смело использовать, и статистка по Google будет примерно такая же.
Основная суть создания семантического ядра - это сбор ключевых фраз, которые так или иначе подходят под тематику сайта. Их надо их как-то оформить, систематизировать. Для этого лучше всего подходят таблицы, например Excel, таблицы в Google Doc или аналогичные.
И для большей эффективности, в таблице семантического ядра можно добавить дополнительные графы:
- Естественно, должна быть графа с самой ключевой фразой.
- Конечно же, графа с наименование рубрики сайта, где эта фраза будет использоваться.
- Можно добавить графу с мета-тегами titile и description и сразу написать заголовок и описание к статье с использованием заданной ключевой фразы. Во-первых, сразу будет понятно, о чём писать статью, во-вторых, потом не надо будет ломать голову и придумывать это.
- Можно сделать графу для указания количества символов в статье по заданной ключевой фразе, чтобы лучше понимать контент-план.
- Если речь идёт о продвижении контекстной рекламой, нужно добавить и стоимость рекламы для каждого запроса.
- Всё, что должно понадобится можно смело записывать в таблицу сематического ядра. Какого-либо шаблона для этого нет, поэтому делать там можно всё, что угодно и удобно.
Частые ошибки при создании семантического ядра
Теперь вы знаете, как правильно создать семантическое ядро сайта. Давайте рассмотрим напоследок, какие частые ошибки бывают у начинающих оптимизаторов.
- Если ядро предусматривает разделение сайта на рубрики, то частой ошибки является создание глубоких уровней вложенности. Рекомендуется второй уровень и не далее. То есть, можно сделать рубрику, подрубрику и всё, дальше делить на более мелкие рубрики уже нельзя.
- Новички могут игнорировать низкочастотные запросы, так как считают, что использовать их нецелесообразно, всё равно они не принесут много трафика. Но на самом деле всё наоборот. Для нового сайта нужны именно низкочастотные, никзоконкурентные запросы.
- Нельзя полностью доверять сервису, с помощью которого будут добываться ключевые фразы. А новички поступают именно так. Машины могут ошибаться и выбрать вам не то, что нужно.
- Не нужно создавать статью ради ключевой фразы. Если вы нашли фразы “срочно продать дом” и “продать дом быстро”, то нет смысла делать для них две разные статьи.
