Как проверить конкурентность запроса: Как определить конкурентность запроса — SEO на vc.ru

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

Пластиковые окна — тело, заказать — спецификатор, в барнауле со скидкой — хвост

Перед сбором определяемся с телом запроса для каждой категории сайта. В последующем это тело можно расширить с помощью общедоступных сервисов, вроде «Яндекс.Вордстата» и других профессиональных инструментов — расширение, поиск дополнительных хвостов, иные формулировки запросов семантики проходит в Кей Коллекторе.

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

Какие еще источники используем

Парсинг конкурентов. Но важно, чтобы конкуренты были с вами в «одном весе». Если вы продаете картриджи для принтеров не стоит сравнивать себя с маркетплейсом или условным «Эльдорадо». Конкурент должен заниматься примерно тем же и обладать схожим ассортиментом.

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

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

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

По каким параметрам собираем семантику

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

Развесовка факторов, влияющих на скоринг семантики. Спасибо Дмитрию Иванову за идеи развесовок

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

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

Если нам известны приоритеты для определенной товарной категории, все фразы этой категории мы отмечаем в выборке меткой «Приоритет» и даем этой выборке коэффициент влияния. После скоринга вверху окажутся не только эффективные фразы с точки зрения параметров скоринга, но и важные для клиента по потенциалу лучшего СРО.

1. Популярность

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

Частотность фразы — насколько часто пользователи вводят именно этот запрос. Фразы бывают высокочастотными с показами выше 1000 в месяц, среднечастотными с запросами от 100 до 1000 и низкочастотными, которые ищут реже 100 раз в месяц.

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

Оцениваем тренд спроса за последние 24 месяца. Растущий тренд свидетельствует об интересе пользователей

2. Конкурентность

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

• Количество документов в обеих поисковых системах — сколько страниц (документов) в индексе поисковых системах Яндекса и Гугла по этому запросу. Чем их больше, тем выше конкурентная борьба по одному ключевому слову.

• Количество главных страниц в выдаче по запросу: чем больше главных страниц в топе, тем сильнее конкуренция идет за место в выдаче — тем труднее будет бороться за место в топе.

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

3. Коммерческость

Запросы бывают информационными, навигационными и коммерческими. Специфика определена интентом пользовательского запроса — что он хочет найти. Для продвижения e-commerce проектов мы исключаем информационные и навигационные запросы.

Для определения коммерческости фразы используем следующие данные:

• Бюджет на продвижение фразы в системе «Яндекс.Директ» — примерные расходы в контексте на месяц для фразы с показами на выбранной позиции в указанном регионе.

• Стоимость за клик в «Яндекс.Директе» по данной фразе — примерная стоимость клика в контексте для фразы с показами на выбранной позиции в регионе.

• Бюджет на продвижение в ссылочных агрегаторах — примерные затраты в месяц для ссылочного продвижения запроса в различных агрегаторах.

4. Текущие позиции

В группе «Текущие позиции» учитывается наличие фраз проекта в топах выдачи (топ-10, топ-30, за пределами топ-100), а также динамика позиций — есть ли рост у проекта в позициях, или наблюдается стагнация.

Для нас это признак того, как проект развивается. Если есть динамика роста по определенным фразам — значит, следует на них обратить внимание в первую очередь. Если фразы «застыли» далеко за топ-100, то они будут не первым приоритетом.

5. Перспективность

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

Смотрим по динамике позиций и экспертной оценке. Например, «схожесть с топом» — насколько проект соответствует топу и на какие потенциальные позиции может претендовать. Например, 6 из 10 проектов с их позиций в топ-10 «выпихнуть» невозможно. Значит для нас потенциальных слотов меньше.

Геозависимость и локализация

Геозависимость запроса. Зависит ли выдача от региона запроса? Например, если вы ищете грузчиков, то для вас важно, чтобы эти грузчики находились в одном городе с вами. А если хотите узнать показания к медицинскому препарату, то вам по-большому счету все равно к какому региону будет относиться релевантный запросу сайт.

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

Рынок недвижимости — яркий пример геозависмых запросов с высокой степенью коммерциализации

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

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

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

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

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

Как определить конкурентность запроса? Какие ключевые слова продвигать?

Что такое конкурентность поискового запроса?

Четвертая классификация запросов — по конкурентности. Так как различных запросов много, может оказаться, что по какому-то запросу конкурентность разная. А что это значит? Это значит, что какой-то запрос могут не включить в семантическое ядро, сайт по нему будет отображаться естественным путем. Например, в Википедии нет SEO-оптимизатора. Семантическое ядро никто в Википедии не составлял, но она имеет огромное количество ссылок, возраст, перелинковки, поэтому с ней тяжело конкурировать. Это естественная выдача по информационным запросам. Но чаще всего конкуренция возникает для коммерческих запросов, а не информационных. Но и коммерческий сайт можно продвинуть естественным путем. Для этого нужно определить, что запрос является не конкурентным и включить его в ядро. Например, можно придумать запрос «купить мужские ботинки зимние 44 размера из крокодиловой кожи в Запорожье». Если мы приложим хотя бы минимальные усилия: напишем запрос в заголовке страницы, используем один раз в контенте и купим 1 ссылку, то, скорее всего, мы окажемся на первой позиции, если ни одного еще такого хитреца не нашлось.

Как можно определить конкурентность запроса?

Чтобы определить конкурентность, нужно проанализировать текущую страницу выдачи по какому-то запросу. Если по данному запросу только первую и вторую страницы в выдаче SEO-оптимизаторы продвигали, то это низкая конкретность. А как определить продвигают сеошники страницу по нужному запросу или нет? Для этого есть инструменты. Также это можно определить визуально. Например, если конкурент включил запрос в title страницы, значит 100%, продвигает. Если нет, значит, мы можем совершить какие-то алгоритмы, действия, которые нужны SEO-оптимизатору, и попадем в топ-3, заняв нишу 3-го, так как он ничего не делает, чтобы на эту позицию попасть. А вот если окажется, что все 10 какие-то усилия совершают, значит это запрос высокой конкурентности.

Какие ключевые слова продвигать?

Есть несколько правил. Во-первых, не нужно придумывать таких запросов, по которым никто не ищет. Во-вторых, нужно попытаться определить не конкурентные запросы и по ним продвигать. Какое количество слов должно быть в ключевом запросе? Лучше от 3 слов, но и нет смысла делать больше 5-6 слов. Можно сделать классификацию по количеству слов, чтобы потом анализировать и подводить итоги. Также должна быть вероятность, что кто-то ищет по такому запросу. Нет смысла продвигать под такие запросы, которые можно придумать один раз в жизни и больше никогда не повторить. Потому что мы под них сайт продвинем, а на нас будут заходить по другим запросам.

Обработка параллельных запросов в RESTful API | Гийома Вигье-Жюста | Запуск

Представьте себе следующий сценарий:

1. Пользователь A запрашивает ресурс 1 через конечную точку GET
2. Пользователь B запрашивает ресурс 1 через конечную точку GET
3. Пользователь A вносит изменения в ресурс 1 и сохраняет свои изменения с помощью запроса PUT
4. Пользователь B вносит изменения в ресурс 1 в тех же полях, что и пользователь A, и сохраняет свои изменения с помощью запроса PUT

Поскольку пользователи A и B оба запросили одну и ту же версию ресурса 1, теперь у вас есть проблема, потому что Запрос PUT, инициированный пользователем B, удалил изменения, сделанные пользователем A, и, скорее всего, пользователь A злится и задается вопросом, почему его изменения больше не отображаются, хотя он клянется, что не забыл сохранить.Вам знаком этот сценарий? Если да, читайте дальше.

Проблема очень проста: пользователи A и B запросили ресурс более или менее одновременно, и получили ту же версии этого ресурса. Затем они оба параллельно внесли изменения в ресурс, и тот, кто сохранил последний, стер изменения другого.

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

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

Оптимистическая блокировка, с другой стороны, позволяет пользователям извлекать ресурс параллельно, однако не позволяет пользователю стереть предыдущую версию ресурса. Если мы возьмем приведенный выше пример сценария, на шагах 1 и 2 пользователи A и B будут извлекать ресурс 1 как, скажем, в версии 38.Когда пользователь A сохраняет ресурс 1, он отправляет в API информацию о том, что сохраняемая версия — это версия 38. Затем API извлекает ресурс из базы данных и сравнивает версию в базе данных с версией, предоставленной в вызове API, и если они отличаются, он не примет операцию сохранения. Когда пользователь A сохраняет версию 38 ресурса, сохранение будет принято, и номер версии будет увеличен, но когда пользователь B попытается сохранить версию 38, ресурс в базе данных будет иметь версию 39, и поэтому сохранение не будет быть принятым, не позволяя пользователю B перезаписывать изменения пользователя A.

Итак, какую блокировку вы должны реализовать в своем RESTful API? Пессимистическая или оптимистичная блокировка?

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

Представьте себе следующий сценарий: пользователь A извлекает ресурс 1, и клиентское приложение автоматически блокирует этот ресурс, когда пользователь A начинает вносить в него изменения.После внесения некоторых изменений в ресурс 1 и их сохранения пользователь A закрывает приложение и уходит в отпуск на 2 недели … Если ваше клиентское приложение каким-либо образом автоматически не разблокировало ресурс 1, ресурс 1 теперь заблокирован и не может быть изменен кем-либо, пока пользователь A не будет вернулся из отпуска … Если вы не хотите рассердить пользователей на вас, я не советую вам идти этим путем.

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

Обратите внимание, что если по какой-то причине это «неудобство», вызванное оптимистической блокировкой, неприемлемо для вас, вы все равно можете реализовать пессимистическую блокировку и установить срок действия блокировки, например, автоматически снять блокировку, созданную 2 часа назад. , и поэтому срок его действия истек. В таком случае ваше клиентское приложение должно будет отразить этот срок действия.

Стандартный способ реализации оптимистической блокировки в RESTful API — использование заголовков Etags и If-Match .Когда ресурс извлекается, он принимается с заголовком Etag , который представляет собой строку символов, определяющих версию извлекаемого ресурса. Когда клиент позже захочет обновить этот ресурс, он должен предоставить значение Etag в заголовке If-Match . Если Etag, указанный в заголовке If-Match , совпадает с версией ресурса в базе данных, ресурс может быть обновлен, в противном случае обновление отклоняется.

Обратите внимание, что если вы используете MongoDB в качестве серверной части и Mongoose в качестве ORM, у вас уже есть встроенный механизм версий, и вам не нужно его реализовывать.Mongoose хранит версии документа в атрибуте __v документа. Все, что вам нужно сделать, это убедиться, что этот атрибут __v увеличивается при каждой операции сохранения. Для этого Mongoose предоставляет очень удобную опцию: optimisticConcurrency (см. Документацию здесь), которая, если она установлена, будет автоматически увеличивать этот атрибут __v при каждой операции сохранения. Однако обратите внимание, что он не будет увеличивать этот атрибут в операции findOneAndUpdate , поэтому вам нужно будет сделать это вручную:

 await q.findOneAndUpdate ({_id}, {
 $ set: body, 
 $ inc: {__v: 1} 
} 

Затем вам нужно будет предоставить этот атрибут __v в каждом запросе GET, либо непосредственно в полезных данных ответа, либо в заголовок Etag , и ваше клиентское приложение затем должно будет отправить вам этот атрибут __v , снова либо в полезных данных запроса, либо в заголовке If-Match .

Когда есть конфликт (ресурс не может быть сохраненным, потому что он был отредактирован тем временем), ваш API должен ответить с кодом состояния HTTP 412 Precondition Failed .Затем клиентское приложение должно будет интерпретировать этот код состояния и показать пользователю понятное сообщение об ошибке.

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

Однако, если некоторые из ваших ресурсов могут обновляться разными пользователями, вы рано или поздно столкнетесь со сценарием, описанным в начале этой статьи.В этом случае я рекомендую реализовать оптимистическую блокировку с использованием заголовков Etag и If-Match , возвращающих 412 Precondition Failed , если ресурс не может быть обновлен.

Стратегии управления параллелизмом API | Мэтью Холлидей | The Startup

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

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

Проблема

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

Простая стратегия… ничего не делать.

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

Чрезмерная оптимизация — дорогостоящая ошибка при разработке программного обеспечения. Это вдвойне верно в отношении мира разработки API, который по самой своей природе включает как минимум две стороны; тех, кто разрабатывает API, и тех, кто его использует.

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

При отсутствии эмпирических данных сделайте оценку на основе наиболее достоверной доступной вам информации. Некоторые факторы, которые следует учитывать:

• Влияние перезаписи данных на бизнес-ценность.
• Количество запросов в единицу времени.
• Количество обновляемых ресурсов.
• Продолжительность времени для завершения одного обновления ресурса.

В первую очередь избегайте проблем с параллелизмом.

Одни и те же данные можно моделировать разными способами… некоторые из которых приводят к большему количеству проблем параллелизма, чем другие.Более крупные и крупнозернистые ресурсы часто можно разбить на более мелкие и детализированные ресурсы, чтобы снизить вероятность конфликта запросов.

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

ETags и Optimistic Locking спешат на помощь!

Прежде чем описывать оптимистическую блокировку, давайте взглянем на ее знакомый аналог; пессимистический блокировка.В схеме пессимистической блокировки клиент блокирует ресурс для исключительного использования, пока он не завершит обновление ресурса. Пессимистическая блокировка обычно нежелательна для разработки REST API. Это заставляет сервер поддерживать состояние, большой REST нет-нет. Это также усложняет дизайн клиента и повышает вероятность взаимоблокировки.

Ввести оптимистическую блокировку.

В оптимистической схеме блокировки запрос на обновление будет успешным только в том случае, если ресурс не был изменен с момента последней проверки клиента .HTTP предоставляет некоторые встроенные механизмы для реализации оптимистической стратегии блокировки с использованием условного заголовка If-Match и ETags (ETags также могут использоваться с запросами GET и HEAD для повышения эффективности кэширования).

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

Чтобы использовать создание запроса с использованием оптимистичного параллелизма, клиентское приложение сначала извлекает ресурс, который оно хочет обновить, и сохраняет ETag, который сервер возвращает с телом ответа. Затем клиентское приложение выполняет все необходимые обновления и отправляет ресурс обратно с заголовком условия If-Match и ETag, полученными ранее. Если ETag совпадает с текущим ETag ресурса, сервер выполняет это обновление и успешно отвечает.В противном случае сервер отклоняет обновление с ответом 412 Precondition Failed .

Стратегии параллелизма для массовых обновлений

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

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

• Если возможно, разрешите успешное выполнение как можно большего числа обновлений отдельных ресурсов в пакете. Что бы вы почувствовали, если бы ваше обновление на 2 миллиона записей было откатано после ожидания 45 минут, потому что один ресурс был обновлен параллельным запросом?
• Если очень большие обновления создают слишком много сложностей, можно рассмотреть возможность снижения предела количества ресурсов, которые клиент может обновить в одном массовом запросе.
• Предоставить потребителям API варианты. Если возможно, позвольте им решить, следует ли откатить массовое обновление в случае одновременных запросов.

Заключение

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

Как запустить нагрузочный тест 50k + одновременных пользователей

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

Обзор быстрых шагов

1.Напишите свой скрипт

2. Протестируйте его локально с помощью JMeter

3. Тестирование BlazeMeter SandBox

4. Настройте количество пользователей на каждый движок, используя 1 консоль и 1 движок

5. Настройте и протестируйте свой кластер (1 консоль и 10-14 модулей)

6. Используйте функцию Master / Slave, чтобы достичь максимальной цели

Прежде чем начать, убедитесь, что у вас установлена ​​последняя версия JMeter от jmeter сообщества JMeter Aapche.apache.org.

Перед тем, как начать, вам необходимо загрузить диспетчер подключаемых модулей JMeter. После того, как вы загрузили файл JAR, поместите его в каталог JMeter lib / ext. Затем запустите JMeter и перейдите в меню «Параметры», чтобы получить доступ к диспетчеру подключаемых модулей.

Есть много способов получить ваш скрипт:

1. Используйте расширение BlazeMeter для Chrome, чтобы записать сценарий
2. Использование JMeter HTTP (S) Test Script Recorder, который в основном настраивает прокси, чтобы вы могли запустить свой тест и записать все
3. Пройдемся вручную до конца и построим все с нуля (возможно, для функциональных / QA-тестов)

Если ваш сценарий является результатом записи (например, шаги 1 и 2), имейте в виду, что:

1. Вам нужно будет изменить определенные параметры, такие как имя пользователя и пароль, или вы можете захотеть установить CSV-файл с этими значениями, чтобы каждый пользователь мог быть уникальным.
2. Вам может потребоваться извлечь такие элементы, как Token-String, Form-Build-Id и другие, используя регулярные выражения, JSON Path Extractor, XPath Extractor — для выполнения запросов как «AddToCart», «Login» и т. Д.
3. Сохраняйте параметры сценария и используйте элементы конфигурации, такие как HTTP-запросы по умолчанию, чтобы упростить себе жизнь при переключении между средами.

Начните отладку вашего скрипта с 1 потока, 1 итерации, используя элемент View Results Tree, Debug Sampler, Dummy Sampler и открытое средство просмотра журнала (в случае сообщения об ошибках JMeter).

Просмотрите все сценарии (истинные и ложные ответы), чтобы убедиться, что сценарий ведет себя должным образом …

После успешного выполнения сценария с использованием 1 потока увеличьте его до 10-20 потоков на 10 минут и проверьте:

1. Если вы хотели, чтобы каждый пользователь был уникальным — так ли это?
2. У вас есть ошибки?
3. Если вы выполняете процесс регистрации, посмотрите на свой бэкэнд — созданы ли учетные записи в соответствии с вашим шаблоном? они уникальны?
4. В сводном отчете вы можете увидеть статистику вашего теста — имеет ли это смысл? (среднее время отклика, ошибок, обращений / с)

Когда ваш скрипт будет готов:

1. Очистите его, удалив все отладочные / фиктивные семплеры и удалив слушатели скриптов
2. Если вы используете Listeners (например, «Сохранить ответы в файл»), убедитесь, что вы не используете никакие пути! , скорее, если это прослушиватель или конфигурация набора данных CSV — убедитесь, что вы не используете путь, который вы использовали локально — вместо этого используйте только имя файла (как если бы оно было в той же папке, что и ваш скрипт)
3. Если вы используете свой собственный JAR-файл (ы), обязательно загрузите его.
4. Если вы используете более 1 группы потоков (или не используемую по умолчанию) — обязательно установите значения перед загрузкой в ​​BlazeMeter.

Если это ваш первый тест — вам следует прочитать эту статью о том, как создавать тесты в BlazeMeter.

SandBox — это фактически любой тест, который насчитывает до 300 пользователей, использует только 1 консоль и до 50 минут.

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

Для этого сначала нажмите серую кнопку: JMeter Engines Я хочу полный контроль! — чтобы получить полный контроль над параметрами ваших испытаний ..

Общие проблемы, с которыми вы можете столкнуться:

1. Брандмауэр — убедитесь, что ваша среда открыта для списка BlazeMeter CIDR (который время от времени обновляется), и внесите их в белый список
2. Убедитесь, что все ваши тестовые файлы e.g: CSV, JAR, JSON, User.properties и т. д. присутствуют
3. Убедитесь, что вы не использовали пути

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

Конфигурация SandBox может быть:

• Двигатели: только консоль (1 консоль, 0 двигателей)
• Потоки: 50-300
• Время разгона: 20 минут
• Итерация: испытание продолжается вечно
• Продолжительность: 30-50 минут

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

Вы должны посмотреть вкладку Waterfall / WebDriver, чтобы увидеть, что запросы в порядке, вы не должны получить никаких ошибок на этом этапе (если это не было вашим намерением).

Вам следует посмотреть вкладку «Мониторинг», чтобы увидеть, сколько памяти и ЦП было использовано — это должно помочь вам в шаге 4, пока вы попытаетесь настроить количество пользователей на каждый движок.

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

Если вы можете использовать данные SandBox, чтобы определить это, отлично!

Здесь я дам способ разобраться в этом, не оглядываясь на данные теста SandBox.

Установите тестовую конфигурацию на:

• Количество ниток: 500
• Наезд 40 минут
• Итерация: forever
• Продолжительность: 50 минут

Используйте 1 консоль и 1 двигатель.

Запустите тест и проследите за движком вашего теста (через вкладку «Мониторинг»).

Если ваш движок не достиг 75% использования ЦП или 85% использования памяти (однократные пики можно игнорировать):

• Измените количество потоков на 700 и снова запустите тест
• Увеличивайте количество потоков, пока не дойдете до 1000 потоков или 60% использования ЦП или памяти

Если ваш движок прошел 75% использования ЦП или 85% использования памяти (одноразовые пики можно игнорировать:

• Посмотрите на момент времени, когда вы сначала достигли 75%, а затем посмотрите, сколько пользователей у вас было к этому моменту.
• Запустите тест еще раз, вместо увеличения на 500 укажите количество пользователей, полученное в предыдущем тесте,
.
• На этот раз установите желаемое ускорение в реальном тесте (5-15 минут — отличное начало) и установите продолжительность на 50 минут.
• Убедитесь, что вы не превышаете 75% использования ЦП или 85% памяти на протяжении всего теста …

Вы можете пойти дальше и уменьшить количество потоков на каждый двигатель на 10% на всякий случай.

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

Кластер — это логический контейнер, который имеет 1 консоль (только 1) и механизмы 0-14.

Даже если вы можете создать тест с более чем 14 движками — он фактически создает 2 кластера (вы можете видеть, что количество консолей будет расти) и клонируете ваш тест…

Максимальное количество 14 двигателей на консоль основано на собственном тестировании BlazeMeter, чтобы гарантировать, что консоль может выдерживать давление 14 двигателей, что создает большой объем данных для обработки.

Итак, на этом шаге мы возьмем тест с шага 4, изменим только количество двигателей и увеличим его до 14.

Запустите тест на протяжении всего последнего теста (1,2,3 ..) часов. Пока выполняется тест, перейдите на вкладку мониторинга и проверьте:

1. Ни один из движков не пропускает 75% ЦП, 85% ограничение памяти
2. Найдите ярлык консоли (вы можете найти его имя, если перейдете на вкладку «Журналы» -> «Сетевая информация» и найдите частный IP-адрес вашей консоли) — он не должен достигать предела 75% ЦП или 85% памяти.

Если консоль достигла этого предела — уменьшите количество двигателей и снова запустите, пока консоль не будет в этих пределах

В конце этого шага вы знаете:

1. Количество пользователей на кластер у вас будет
.
2. Хитов / с на кластер вы достигнете

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

Мы подошли к финальной стадии.

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

Допустим, эти значения:

• 1 движок может иметь 500 пользователей
• В кластере будет 12 двигателей
• Наша цель — 50K test

Итак, для этого нам нужно создать 50,000 \ (500 * 12) = 8.3 кластера ..

Мы могли бы использовать 8 кластеров по 12 двигателей (48K) и 1 кластер с 4 двигателями (другие 2K), но было бы лучше распределить нагрузку следующим образом:

Вместо 12 машин на кластер мы будем использовать 10, поэтому мы получим 10 * 500 = 5 КБ из каждого кластера, и нам понадобится 10 кластеров, чтобы достичь 50 КБ.

Это нам поможет:

1. Не поддерживаются 2 разных типа тестов
2. Мы можем вырасти на 5 КБ, просто скопировав существующий кластер (5 КБ гораздо чаще, чем 6 КБ)
3. При необходимости мы всегда можем добавить больше…

Теперь мы готовы создать наш финальный тест Master / Slave с 50K пользователями:

1. Изменение имени теста с «Мой тест продукта» на «Мой тест продукта — подчиненный 1».
2. Итак, мы возвращаемся к нашему тесту на шаге 5 и в разделе Advanced Test Properties меняем его с Standalone на Slave.
3. Нажимаем сохранить — теперь у нас есть первый из 9 Рабов и 1 Мастер.
4. Вернитесь к своему «My prod test -slave 1».
5. Нажмите Дублировать.
6. Теперь повторяйте шаги 1–5, пока не создадите все 9 ведомых устройств.
7. Вернитесь к своему «My prod test -salve 9» и нажмите «Дублировать».
8. Измените имя теста на «My prod test -Master».
9. Перейдите в Advanced Test Properties и измените его с Slave на Master.
10. Отметьте все только что созданные ведомые устройства (My prod test -salve 1..9) и нажмите «Сохранить».

Ваш тест Master-Slave для 50K пользователей готов к работе.Нажав кнопку «Старт» на главном устройстве, вы запустите 10 тестов (1 мастер и 9 подчиненных устройств) с 5K пользователями из каждого из них.

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

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

Хотите легко запускать тесты производительности для 50 000 виртуальных пользователей и даже до 2 миллионов виртуальных пользователей? Вы можете попробовать BlazeMeter бесплатно. Просто введите свой URL-адрес в поле ниже, и ваш тест начнется через несколько минут.

одновременных запросов — KrakenD API Gateway

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

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

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

 ...,
"конечные точки": [
{
  "конечная точка": "/ продукты",
  "метод": "ПОЛУЧИТЬ",
  "concurrent_calls": 3,
  "backend": [
    {
        "хозяин": [
            "http://server-01.api.com:8000",
            "http://server-02.api.com:8000"
        ],
        "url_pattern": "/ foo",
  ...
  

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

Обратите внимание, что, несмотря на то, что этот бэкэнд имеет только два сервера для обработки нагрузки, для параметра concurrent_calls установлено значение три.Эти две настройки не связаны, и, тем не менее, KrakenD собирается открыть три соединения с этими двумя серверами. Какой сервер получит 1,2 или все три, зависит от решения внутреннего балансировщика нагрузки.

Какой идеальный номер для

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

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

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

Как работает

KrakenD отправляет до N concurrent_calls вашим бэкэндам для ** того же запроса к конечной точке. Когда получен первый успешный ответ, KrakenD отменяет оставшиеся запросы и игнорирует любые предыдущие сбои.Только в случае, если все concurrent_calls терпят неудачу, конечная точка также получает отказ.

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

Воздействие одновременных запросов

Чтобы продемонстрировать влияние этого компонента, давайте представим два разных сценария: счастливый и печальный. Здесь у вас есть CDF (совокупное распределение), и PDF (распределение вероятностей) для этих двух случаев (временной диапазон — это просто заполнитель для любых ваших фактических значений времени отклика, замените 100 своим max_response_time ):

Напоминаем: для графиков CDF чем левее линия, тем лучше.Для графиков PDF, чем левее и чем меньше пик, тем лучше.

На следующем графике показан эффект использования разных уровней параллелизма для счастливого случая (обратите внимание, как время отклика концентрируется около 20% от max_response_time ):

Здесь у вас есть эффекты для печального случая:

Компонент одновременного запроса также снижает частоту ошибок открытой конечной точки на порядков .

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

Как выполнить тест производительности веб-сервера?

Знаете ли вы среднее время отклика вашего веб-сайта? Вы знаете, сколько одновременных пользователей может обрабатывать ваш сайт?

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

Бенчмаркинг может помочь вам принять решение;

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

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

Я использовал веб-сервер Apache и Nginx, размещенный в DigitalOcean, для его тестирования.

ApacheBench

ApacheBench (ab) — это программа командной строки с открытым исходным кодом, которая работает с любым веб-сервером. В этом посте я объясню, как установить эту небольшую программу и выполнить нагрузочный тест, чтобы сравнить результаты.

Apache

Давайте установим ApacheBench с помощью команды yum.

  yum install httpd-tools  

Если у вас уже есть httpd-tools, вы можете проигнорировать это.

Теперь давайте посмотрим, как он выполняет 5000 запросов с параллелизмом 500.

  [[электронная почта защищена] ~] # ab -n 5000 -c 500 http: // localhost: 80 /
Это ApacheBench, версия 2.3 <$ Revision: 655654 $>
Авторское право 1996 г., Адам Твисс, Zeus Technology Ltd, http://www.zeustech.net/
Лицензия предоставлена ​​Apache Software Foundation, http://www.apache.org/
Тестирование localhost (проявите терпение)
Выполнено 500 запросов
Выполнено 1000 запросов
Выполнено 1500 запросов
Выполнено 2000 запросов
Выполнено 2500 запросов
Выполнено 3000 запросов
Выполнено 3500 запросов
Выполнено 4000 запросов
Выполнено 4500 запросов
Выполнено 5000 запросов
Выполнено 5000 запросов
Серверное программное обеспечение: Apache / 2.2,15
Имя хоста сервера: localhost
Порт сервера: 80
Путь к документу: /
Длина документа: 4961 байт
Уровень параллелизма: 500
Время на тесты: 13,389 секунды
Выполненных запросов: 5000
Неудачные запросы: 0
Ошибок записи: 0
Не-2xx ответов: 5058
Всего передано: 26094222 байта
Передано HTML: 25092738 байт
Запросы в секунду: 373,45 [# / сек] (среднее)
Время на запрос: 1338.866 [мс] (среднее)
Время на запрос: 2,678 [мс] (среднее значение для всех одновременных запросов)
Скорость передачи: 1903,30 [Кбайт / сек] получено
Время подключения (мс)
мин. среднее [+/- sd] медианное макс.
Подключить: 0 42 20,8 41 1000
Обработка: 0428 2116,5 65 13310
Ожидание: 0416 2117,7 55 13303
Итого: 51 470 2121,0 102 13378
Процент запросов, обслуженных за определенное время (мс)
50% 102
66% 117
75% 130
80% 132
90% 149
95% 255
98% 13377
99% 13378
100% 13378 (самый длинный запрос)
[[адрес электронной почты защищен] ~] #  

Итак, как видите, Apache обработал 373 запроса в секунду, , а всего потребовалось 13.389 секунд для обслуживания общего количества запросов.

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

Nginx

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

  [[электронная почта защищена] ~] # ab -n 5000 -c 500 http: // localhost: 80 /
Это ApacheBench, версия 2.3 <$ Revision: 655654 $>
Авторские права 1996 г. Адам Твисс, Zeus Technology Ltd, http: // www.zeustech.net/
Лицензия предоставлена ​​Apache Software Foundation, http://www.apache.org/
Тестирование localhost (проявите терпение)
Выполнено 500 запросов
Выполнено 1000 запросов
Выполнено 1500 запросов
Выполнено 2000 запросов
Выполнено 2500 запросов
Выполнено 3000 запросов
Выполнено 3500 запросов
Выполнено 4000 запросов
Выполнено 4500 запросов
Выполнено 5000 запросов
Выполнено 5000 запросов
Серверное программное обеспечение: nginx / 1.10.1
Имя хоста сервера: localhost
Порт сервера: 80
Путь к документу: /
Длина документа: 3698 байт
Уровень параллелизма: 500
Время, затраченное на тесты: 0.758 секунд
Выполненных запросов: 5000
Неудачные запросы: 0
Ошибок записи: 0
Всего передано: 19660000 байт
Передано HTML: 184
 байт
Запросы в секунду: 6593,48 [# / сек] (среднее)
Время на запрос: 75,832 [мс] (среднее)
Время на запрос: 0,152 [мс] (среднее значение для всех одновременных запросов)
Скорость передачи: 25317,93 [Кбайт / сек] получено
Время подключения (мс)
мин. среднее [+/- sd] медианное макс.
Подключить: 0 6 11.0 2 53
Обработка: 5 19 8,2 17 53
Ожидание: 0 18 8,2 16 47
Итого: 10 25 17,4 18 79
Процент запросов, обслуженных за определенное время (мс)
50% 18
66% 21
75% 21
80% 22
90% 69
95% 73
98% 75
99% 76
00% 79 (самый длинный запрос)
[[адрес электронной почты защищен] ~] #  

ВАУ!

Вы это видели?

Nginx обработал 6593 запроса в секунду ! Победитель.

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

Вышеупомянутый тест проводился на CentOS 6.8, 64 бит. Вы можете попробовать несколько комбинаций версии ОС и веб-сервера для достижения оптимальных результатов.

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

SIEGE

SIEGE — это утилита для тестирования нагрузки HTTP, поддерживаемая в UNIX. Вы можете поместить несколько URL-адресов в текстовый файл для проведения нагрузочных тестов.Вы можете установить siege с помощью yum.

 # yum install siege 

Давайте запустим тест с 500 одновременными запросами в течение 5 секунд.

 [[электронная почта защищена] ~] # осада -q -t 5S -с 500 HTTP: // локальный /
Снятие осады сервера ... готово.
Транзакции: 4323 обращения
Доступность: 100.00%
Затраченное время: 4,60 секунды
Передано данных: 15,25 МБ
Время отклика: 0,04 сек.
Скорость транзакции: 939.78 транс / сек
Пропускная способность: 3,31 МБ / с
Параллелизм: 37,97
Успешных сделок: 4323
Неудачные транзакции: 0
Самая длинная транзакция: 1.04
Самая короткая транзакция: 0,00
[[электронная почта защищена] ~] #
 

Чтобы разбить параметры.

-q — для тихой работы (без отображения деталей запроса)

-t — запустить 5 секунд

-c — 500 одновременных запросов

Итак, как видите, доступность составляет 100%, а время отклика равно 0.04 секунды. Вы можете настроить параметр нагрузочного теста в зависимости от вашей цели.

Али

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

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

  [адрес электронной почты защищен]: ~ # ali
цель не указана
Применение:
  ali [флаги] <целевой URL>

Флаги:
  -b, --body string Тело запроса для отправки.-B, --body-file string Путь к файлу, содержимое которого будет установлено как тело HTTP-запроса.
      --debug Запускать в режиме отладки.
  -d, --duration duration Время, в течение которого отправляются запросы к целям. Дайте 0 за бесконечную атаку. (по умолчанию 10 с)
  -H, --header strings Заголовок запроса для отправки. Может использоваться несколько раз для отправки нескольких заголовков.
  -k, --keepalive Использовать постоянные соединения. (по умолчанию true)
  -M, --max-body int Максимальное количество байтов для захвата из тела ответа.Дайте -1 без ограничений. (по умолчанию -1)
  -m, --method string Метод HTTP-запроса для каждого запроса. (по умолчанию "ПОЛУЧИТЬ")
  -r, --rate int Частота запросов в секунду, выполняемых для целей. Укажите 0, тогда он будет отправлять запросы как можно быстрее. (по умолчанию 50)
  -t, --timeout duration Тайм-аут для каждого запроса. 0s означает отключение тайм-аутов. (по умолчанию 30 с)
  -v, --version Вывести текущую версию.

Примеры:
  ali --duration = 10m --rate = 100 http: // host.xz

Автор:
  Ре Накао <[адрес электронной почты защищен]>
[адрес электронной почты защищен]: ~ #  

Как вы можете видеть выше, у вас есть возможность отправлять заголовки HTTP, продолжительность теста, ограничение скорости, тайм-аут и многое другое. Я провел быстрый тест на Geekflare Tools, и вот результат:

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

Gobench

Gobench написан на языке Go и представляет собой простую утилиту нагрузочного тестирования для оценки производительности веб-сервера.Он поддерживает более 20 000 одновременных пользователей, чего не поддерживает ApacheBench.

Apache JMeter

JMeter — один из самых популярных инструментов с открытым исходным кодом для измерения производительности веб-приложений. JMeter — это приложение на основе java, а не только веб-сервер, но вы можете использовать его против PHP, Java. ASP.net, SOAP, REST и т. Д.

JMeter получил приличный дружественный графический интерфейс, а последняя версия 3.0 требует Java 7 или выше для запуска приложения. Вы должны попробовать JMeter, если ваша цель — оптимизировать производительность веб-приложения.

wrk

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

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

Рассмотрим пример запуска теста в течение 5 минут с 500 одновременными пользователями с 8 потоками.

  wrk –t8 –c500 -d300s http: // localhost  

Пушка

Автопушка написана на Node.js. Вы можете использовать его программно, через API или отдельную утилиту. Все, что вам нужно, — это установить NodeJS в качестве предварительного условия.

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

Роторный погрузчик

curl-loader написан на C для имитации загрузки приложений и поддерживает SSL / TLS. Наряду с тестом веб-страницы вы также можете использовать этот инструмент с открытым исходным кодом для выполнения нагрузки на FTP-серверы.

Вы можете создать план тестирования с сочетанием HTTP, HTTPS, FTP и FTPS в одной пакетной конфигурации.

httperf

httperf — это высокопроизводительный инструмент, ориентированный на тесты на микро- и макроуровнях. Он поддерживает протоколы HTTP / 1.1 и SSL.

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

  httperf --server localhost --port 80 --num-conns 1000 --rate 100  

Приведенная выше команда будет тестировать со 100 запросами в секунду для 1000 запросов HTTP.

Tsung

Tsung — это многопротокольный распределенный инструмент для стресс-тестирования серверов HTTP, SOAP, PostgreSQL, LDAP, XAMP, MySQL. Он поддерживает HTTP / 1.0, HTTP / 1.1, а файлы cookie обрабатываются автоматически.

Создание отчета возможно с помощью Tsung.

Заключение

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

Затем не забывайте следить за эффективностью своего сайта.

Простое руководство по параллелизму JavaScript в Node.js

Готов поспорить, что вы знакомы с параллелизмом JavaScript в Node.js. Кроме того, скорее всего, вы уже слышали, что Node отлично справляется с обработкой нескольких операций асинхронного ввода-вывода. Но задумывались ли вы, что это на самом деле означает? Есть много потенциальных вопросов. Как именно это делается в Node.js? Разве это не однопоточное? А как насчет операций, отличных от ввода-вывода? Есть ли способ справиться с ними, не заставляя ваше приложение перестать отвечать на запросы? В статье я надеюсь прояснить, как Node борется с асинхронностью под капотом.Я постараюсь объяснить, о каких потенциальных ловушках вам следует знать. Кроме того, я сосредоточусь на том, как новые функции Node могут помочь вам продвинуть ваши приложения еще дальше, чем когда-либо прежде. Давайте нырнем!

Давайте начнем с теории

Прежде чем я начну говорить о Node.js, давайте быстро выделим два термина, которые могут немного запутать. Это одновременный и параллельный параллелизм в Node.js . Представим, что у вас есть две операции: A и B.Если бы вы вообще не имели дело с с каким-либо параллелизмом , вы бы начали с операции A. После ее завершения вы бы запустили операцию B, чтобы они просто выполнялись последовательно. Такое исполнение будет выглядеть так, как показано на схеме ниже.

После завершения операции A вы запускаете операцию B — они выполняются последовательно.

Если вы хотите обрабатывать эти операции одновременно, выполнение будет выглядеть следующим образом.

Альтернативным решением является одновременная обработка операций.

Эти операции не выполняются последовательно, но и не выполняются одновременно. Вместо этого процесс «прыгает» или переключает контекст между ними.

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

Третий вариант — параллельное выполнение операций.

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

Узел использовал несколько иной подход к одновременной обработке нескольких одновременных запросов, если сравнить его с некоторыми другими популярными серверами, такими как Apache.Создание нового потока для каждого запроса обходится дорого. Кроме того, потоки ничего не делают, ожидая результата других операций (например, чтения базы данных). Вот почему Node вместо этого использует один поток. Такой подход имеет множество преимуществ. Создание новых потоков не требует дополнительных затрат. Кроме того, ваш код намного проще рассуждать, поскольку вам не нужно беспокоиться о том, что произойдет, если два потока обращаются к одной и той же переменной. Потому что этого просто не может быть. Есть и недостатки. Node — не лучший выбор для приложений, которые в основном связаны с интенсивными вычислениями с использованием ЦП.С другой стороны, он отлично справляется с обработкой нескольких запросов ввода-вывода. Итак, давайте немного сосредоточимся на этой части.

Операции ввода-вывода и узел

Во-первых, я должен ответить на вопрос: что вы подразумеваете под операциями ввода-вывода? Это операции, которые взаимодействуют с данными извне вашего приложения. Это означает HTTP-запросы, чтение и запись с диска или операции с базой данных, и это лишь некоторые из них. Ввод-вывод в Node бывает двух видов: блокирующий и неблокирующий. Очень важно различать эти два.«Блокировка» в «блокировании операций ввода-вывода» довольно информативна. Это означает, что следующие операции заблокированы и они должны ждать, пока выполняется текущая операция. Давайте посмотрим на пример.

В этом примере вы запускаете первое чтение, а затем, только после его завершения, запускаете второе. console.log произойдет после завершения обоих чтений.

Неблокирующая модель работает по-другому. Давайте еще раз рассмотрим пример.

Здесь запускается первая операция чтения, но код не останавливается. Вы также запускаете второе чтение и сразу после этого — console.log записывает в консоль. А как насчет результатов двух операций чтения? Что ж, они будут обрабатываться асинхронно. Это означает, что вы получите их результаты в будущем, и у вас нет гарантии, какая операция завершится раньше.

Нужна поддержка первоклассного программирования на Node.js?

💚 Узнайте, чего вы можете достичь с помощью крупнейшей в Польше команды Node, которая создает ориентированные на производительность приложения для миллионов пользователей.

Какой из них выбрать?

Вместо ответа проведем эксперимент. Давайте воспользуемся Express и создадим очень простой HTTP-сервер с двумя конечными точками. Первый считывает некоторые данные из файла асинхронно (неблокирующий ввод-вывод), а другой — синхронно (блокирующий ввод-вывод). Предположим, вы обернули стандартные методы readFile и readFileSync с помощью некоторой магии, поэтому на их завершение уходит дополнительно 75 мс. Это будет выглядеть так.

Если вы хотите сравнить производительность этих двух конечных точек, вы можете использовать один из доступных инструментов тестирования (допустим, вас интересует, сколько запросов вы можете обработать в течение 5 секунд и до 10 запросов одновременно).Я выбрал Apache Benchmark. Он существует уже довольно давно, но встроен в macOS. Он отлично выполняет свою работу. Давайте сначала запустим следующий тест для синхронной / блокирующей конечной точки.

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

Как видите, вы можете обрабатывать около 12,1 запроса в секунду, что имеет смысл. Вы можете обрабатывать только один запрос за раз, это занимает около 80 мс (75 из вашего «дополнительного» времени чтения плюс несколько миллисекунд на чтение файла и обработку запроса).Таким образом, вы можете легко подсчитать, сколько запросов в секунду вы можете обработать. Это 1000 мс (1 секунда) / 80 мс = 12,5 запроса в секунду, так что вы довольно близко.

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

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

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

Но… как?

Как видите, Node работает достаточно хорошо, когда дело касается асинхронной обработки операций ввода-вывода. Это может быть немного удивительно, когда кто-то знает, что он работает только с одним потоком. Разве один поток не приравнивается к одной операции за раз? Ну… да и нет. Чтобы быть менее расплывчатым, вы действительно можете обрабатывать только одну операцию JavaScript за один раз, однако вы можете воспользоваться тем фактом, что ядра современных операционных систем являются многопоточными.Таким образом, вы можете делегировать им операции ввода-вывода. Это подводит нас к другому вопросу. Когда такие операции завершены, как Node узнает, что пора их обработать? Вы можете себе представить, что это не может произойти в любое время, иначе работать с вашими приложениями будет просто кошмаром. Представьте, что вы выполняете операцию, и вдруг в ее середине срабатывает обратный вызов, потому что операция с диском только что завершилась. Думаю, вы согласитесь, что это не лучший вариант. Итак, давайте представим того, кто поможет Node справиться со всем этим беспорядком.

См. Также: Swoole: это узел в PHP?

Что такое цикл событий JavaScript?

Давайте кратко объясним, что такое цикл событий и как он работает. Ранее я упоминал, что вам нужен какой-то «менеджер», чтобы иметь возможность обрабатывать асинхронные операции. Именно это и делает Event Loop. Давайте посмотрим на пример асинхронной операции.

Интересная часть здесь — это функция, которую вы передаете в качестве последнего аргумента. Это функция обратного вызова, которая будет вызываться после завершения операции, но не сразу.Мы договорились, что такое никогда не должно происходить, и Event Loop позаботится об этом. Как только ваша операция будет завершена, вместо того, чтобы сразу вызвать обратный вызов, он поместит ее в специальную очередь. Как только появится возможность безопасно обработать это, ваши обратные вызовы будут помещены в стек, а затем выполнены один за другим. Здесь вы должны быть осторожны, даже если ваша операция ввода-вывода была асинхронной, обратный вызов будет обрабатываться в основном потоке, если это операция JS. Итак, если вы занимаетесь чем-то, отнимающим много времени, вы блокируете цикл событий.

Это, конечно, большое упрощение работы Event Loop. Если вы хотите узнать об этом больше, это видео станет отличным введением.

Эта серия в блоге Insider Attack объясняет это гораздо глубже.

А как насчет операций без ввода-вывода?

Хорошо, я рассмотрел часть информации об использовании блокирующего и неблокирующего ввода-вывода. Вы видели, что Node неплохо справляется с последним, и теперь знаете, как это делать.Цикл событий для победы! А что насчет того, что не занимается вводом-выводом, но может обрабатывать за вас тяжелые вычисления? Например — сортировка огромного списка. К сожалению, именно здесь однопоточная среда Node не проявляет такой яркости. Вернемся к нашему примеру с Express API. Вы видели, что Node довольно хорошо справляется с обработкой запросов к вашей асинхронной конечной точке. Что произойдет, если тот же API предоставит новую конечную точку, которая выполнит тяжелые вычисления, которые займут несколько секунд?

Теперь представим сценарий, в котором эта конечная точка используется некоторым пакетным заданием для обработки некоторых данных.В таком сценарии вы даже не выполняете никаких одновременных запросов. Вместо этого вы следите за тем, чтобы ваш сервер постоянно вращался и выполнял некоторую работу за вас. Что произойдет, если вы запустите несколько тестов на своей старой асинхронной конечной точке (назовем ее / async ), в то время как задача, интенсивно использующая процессор, постоянно выполняется? Посмотрим.

Ага, ты прав. В настоящий момент ваш API практически не отвечает. Если вы не знаете ограничений единственного потока Node, то, к сожалению, вы можете довольно легко добиться такой невосприимчивости.Есть ли что-нибудь, что можно сделать, чтобы как-то исправить это дело? Одна идея, которая приходит в голову, — это масштабировать ваше приложение. Но для этого вам не понадобится помощь команды DevOps. К счастью, в Node есть несколько встроенных механизмов, которые позволяют вам этого добиться.

Cluster mode

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

Один экземпляр Node.js работает в одном потоке. Чтобы воспользоваться преимуществами многоядерных систем, пользователь иногда может захотеть запустить кластер Node.js для обработки нагрузки.

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

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

Ничего особенного, правда? Тот факт, что вам не нужно беспокоить команду DevOps, делает его еще лучше! Если вы запустите свой API, вы увидите, что действительно создали некоторые процессы.

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

Выглядит неплохо, не правда ли? Но вы, вероятно, согласитесь, что ваша конечная точка с интенсивным использованием ЦП сейчас не так загружена. Что, если кто-то решил ускорить некоторые вещи и запустить, скажем, пять одновременных заданий (или любое количество заданий, превышающее количество процессоров на сервере), которые потребляют эту конечную точку? Вы увидите то же самое, что и до введения режима кластера.Никаких ответов. И что произойдет, если вы предоставите эту конечную точку общественности, чтобы весь мир мог ее использовать? Вы можете видеть, что каким бы красивым и простым в использовании ни был режим кластера, он не решит проблему, если вы сможете так быстро отключить каждый процесс.

Значит, вы обречены? К счастью, это не так. Некоторое время назад один из выпусков Node преподнес нам всем приятный сюрприз, а именно…

рабочих потоков!

Рабочие потоки все еще являются экспериментальной функцией, поэтому использование их в производственной среде, вероятно, не лучшая идея.Но есть шанс, что это скоро изменится. Рабочие потоки позволяют выполнять JavaScript параллельно. Это похоже на то, что вы можете использовать в вышеупомянутом сценарии. Давайте быстро рассмотрим, как можно внедрить рабочие потоки в свой API. Первое, что вам нужно сделать, это создать новый файл. Я назвал его heavy-computing-with-threads.js .

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

Теперь вам просто нужно изменить свой Express API, чтобы он использовал эту версию алгоритма, интенсивно использующего процессор.

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

Заинтересованы в разработке микросервисов? 🤔 Обязательно ознакомьтесь с нашим отчетом «Состояние микросервисов в 2020 году», основанным на мнениях более 650 экспертов по микросервисам!

Еще несколько вещей, которые нужно запомнить

Помимо того, что они полезны при использовании экспериментальных рабочих потоков, вы также должны помнить, что они не обязательно полезны для обработки операций ввода-вывода. То, что уже было встроено в Node до Worker Threads, будет работать намного лучше.И последнее: если вы посмотрите на свой API, использующий потоки, вы увидите, что запускаете новый поток для каждого запроса. В долгосрочной перспективе это не будет слишком эффективным. Вместо этого вам следует создать пул потоков и повторно использовать их. В противном случае стоимость создания новых потоков превысит их преимущества.

Подводя итог

Надеюсь, я вкратце рассказал вам о некоторых ловушках, с которыми вы можете столкнуться, если не знаете об однопоточности Node.Не забывайте отдавать предпочтение неблокирующему вводу-выводу над блокирующим вводом-выводом. Кроме того, вы должны иметь в виду, что каждая операция JavaScript будет блокировать цикл событий, и что длительные операции особенно опасны в этом отношении. Помните о встроенном масштабировании, которое дает вам режим кластера, но также имейте в виду, что он не обязательно решит проблемы, связанные с интенсивными операциями с ЦП в Node. Для них совсем недавно появилось гораздо лучшее решение — рабочие потоки. Просто имейте в виду, что они все еще экспериментальны, но следите за новейшими выпусками Node, так как это может измениться в любое время!

Рафал Островски

Узел.js Developer

.NET-разработчик, ставший поклонником JavaScript. В настоящее время занимается созданием крутых вещей с помощью Node.js. То есть, если он не просто путешествует или не едет на мотоцикле.

Параллелизм | Документация по Cloud Run | Google Cloud

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

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

Чтобы дать вам больше контроля, Cloud Run предоставляет параметр concurrency который указывает максимальное количество запросов, которые могут быть обработаны одновременно данным экземпляром контейнера.

Значения параллелизма

По умолчанию экземпляры контейнера Cloud Run могут получать множество запросов на за одно и то же время (максимум до 250).Обратите внимание, что для сравнения решения «Функции как услуга» (FaaS), такие как Облачные функции имеют фиксированный параллелизм 1.

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

Указанное значение параллелизма является максимальным, и Cloud Run может не отправить столько запросов к данному экземпляру контейнера, если ЦП экземпляра уже широко используется.

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

Когда ограничивать параллелизм одним запросом за раз.

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

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

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

Пример использования

Следующие метрики показывают вариант использования, когда 400 клиентов делают 3 запроса. в секунду для службы Cloud Run, для которой установлен максимальный параллелизм из 1. Зеленая верхняя строка показывает запросы с течением времени, нижняя синяя строка показывает количество экземпляров контейнера, которые начали обрабатывать запросы.

Следующие показатели показывают, что 400 клиентов делают 3 запроса в секунду к Служба Cloud Run, для которой установлен максимальный параллелизм 80. Зеленый верхняя строка показывает запросы с течением времени, нижняя синяя строка показывает количество экземпляры контейнеров начали обрабатывать запросы. Обратите внимание, что гораздо меньше экземпляры необходимы для обработки одного и того же объема запросов.

Что дальше

Чтобы управлять параллелизмом ваших сервисов Cloud Run, см. Настройка параллелизма.

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