One place for hosting & domains

      вебсервера

      Установка веб-сервера Apache в Ubuntu 20.04


      Введение

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

      В этом обучающем руководстве мы расскажем, как установить веб-сервер Apache на сервере Ubuntu 20.04.

      Предварительные требования

      Прежде чем начать прохождение настоящего обучающего модуля, необходимо настроить на сервере обычного пользователя non-root user с привилегиями sudo. Также вам потребуется включить базовый брандмауэр, чтобы заблокировать все порты, кроме необходимых. Вы научитесь настраивать учетную запись обычного пользователя и брандмауэр для вашего сервера, следуя указаниям руководства Начальная настройка сервера Ubuntu 20.04.

      Создав учетную запись, войдите в систему как non-root user.

      Шаг 1 — Установка Apache

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

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

      Затем установим пакет apache2:

      После подтверждения установки apt выполнит установку Apache и всех требуемых зависимостей.

      Шаг 2 — Настройка брандмауэра

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

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

      Выведите список профилей приложений ufw, введя следующую команду:

      Вы увидите список профилей приложений:

      Output

      Available applications: Apache Apache Full Apache Secure OpenSSH

      Как показал вывод, есть три профиля, доступных для Apache:

      • Apache: этот профиль открывает только порт 80 (нормальный веб-трафик без шифрования)
      • Apache Full: этот профиль открывает порт 80 (нормальный веб-трафик без шифрования) и порт 443 (трафик с шифрованием TLS/SSL)
      • Apache Secure: этот профиль открывает только порт 443 (трафик с шифрованием TLS/SSL)

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

      Для проверки изменений введите:

      В выводе будет представлен список разрешенного трафика HTTP:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere Apache ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) Apache (v6) ALLOW Anywhere (v6)

      Как показал вывод, профиль был активирован для доступа к веб-серверу Apache.

      Шаг 3 — Проверка веб-сервера

      В конце процесса установки Ubuntu 20.04 запускает Apache. Веб-сервер уже должен быть запущен и работать.

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

      • sudo systemctl status apache2

      Output

      ● apache2.service - The Apache HTTP Server Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled) Active: active (running) since Thu 2020-04-23 22:36:30 UTC; 20h ago Docs: https://httpd.apache.org/docs/2.4/ Main PID: 29435 (apache2) Tasks: 55 (limit: 1137) Memory: 8.0M CGroup: /system.slice/apache2.service ├─29435 /usr/sbin/apache2 -k start ├─29437 /usr/sbin/apache2 -k start └─29438 /usr/sbin/apache2 -k start

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

      Откройте страницу Apache по умолчанию, чтобы подтвердить работу программного обеспечения через ваш IP-адрес: Если вы не знаете IP-адрес вашего сервера, есть несколько способов узнать его с помощью командной строки.

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

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

      Еще один вариант — использовать инструмент Icanhazip, который должен выдать вам ваш публичный IP-адрес, видимый в другом расположении в Интернете:

      Когда вы узнаете IP-адрес вашего сервера, введите его в адресную строку браузера:

      http://your_server_ip
      

      Вы увидите веб-страницу Ubuntu 20.04 Apache по умолчанию:

      Страница Apache по умолчанию

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

      Шаг 4 — Управление процессом Apache

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

      Чтобы остановить веб-сервер, введите:

      • sudo systemctl stop apache2

      Чтобы запустить остановленный веб-сервер, введите:

      • sudo systemctl start apache2

      Чтобы остановить и снова запустить службу, введите:

      • sudo systemctl restart apache2

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

      • sudo systemctl reload apache2

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

      • sudo systemctl disable apache2

      Чтобы перезагрузить службу для запуска во время загрузки, введите:

      • sudo systemctl enable apache2

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

      Шаг 5 — Настройка виртуальных хостов (рекомендуется)

      При использовании веб-сервера Apache вы можете использовать виртуальные хосты (аналогичные серверным блокам в Nginx) для инкапсуляции данных конфигурации и размещения на одном сервере нескольких доменов. Мы создадим домен your_domain, но вы должны заменить это имя собственным доменным именем. О том, как настроить доменное имя с помощью DigitalOcean, можно узнать из нашей сетевой документации.

      В Apache в Ubuntu 20.04 по умолчанию включен один серверный блок, настроенный на обслуживание документов из директории /var/www/html. Хотя это хорошо работает для отдельного сайта, при хостинге нескольких сайтов это неудобно. Вместо изменения /var/www/html мы создадим в /var/www структуру директорий для нашего сайта your_domain, оставив /var/www/html как директорию по умолчанию для вывода в случае, если запросу клиента не соответствуют никакие другие сайты.

      Создайте следующую директорию для your_domain:

      • sudo mkdir /var/www/your_domain

      Затем назначьте владение директорией с помощью переменной среды $USER:

      • sudo chown -R $USER:$USER /var/www/your_domain

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

      • sudo chmod -R 755 /var/www/your_domain

      Затем создайте в качестве примера страницу index.html, используя nano или свой любимый редактор:

      • sudo nano /var/www/your_domain/index.html

      Добавьте в страницу следующий образец кода HTML:

      /var/www/your_domain/index.html

      <html>
          <head>
              <title>Welcome to Your_domain!</title>
          </head>
          <body>
              <h1>Success!  The your_domain virtual host is working!</h1>
          </body>
      </html>
      

      Сохраните файл и закройте его после завершения.

      Для обслуживания этого контента Apache необходимо создать файл виртуального хоста с правильными директивами. Вместо изменения файла конфигурации по умолчанию, расположенного в /etc/apache2/sites-available/000-default.conf, мы создадим новый файл в /etc/apache2/sites-available/your_domain.conf:

      • sudo nano /etc/apache2/sites-available/your_domain.conf

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

      /etc/apache2/sites-available/your_domain.conf

      <VirtualHost *:80>
          ServerAdmin webmaster@localhost
          ServerName your_domain
          ServerAlias www.your_domain
          DocumentRoot /var/www/your_domain
          ErrorLog ${APACHE_LOG_DIR}/error.log
          CustomLog ${APACHE_LOG_DIR}/access.log combined
      </VirtualHost>
      

      Обратите внимание, что мы изменили DocumentRoot на новую директорию, а ServerAdmin — на адрес электронной почты, доступный администратору сайта your_domain. Также мы добавили две директивы: директиву ServerName, которая устанавливает базовый домен и должна соответствовать определению виртуального хоста, и директиву ServerAlias, которая задает дополнительные имена, которые должны давать совпадение, как если бы они были базовыми именами.

      Сохраните файл и закройте его после завершения.

      Активируем файл с помощью инструмента a2ensite:

      • sudo a2ensite your_domain.conf

      Отключите сайт по умолчанию, определеный в 000-default.conf:

      • sudo a2dissite 000-default.conf

      Затем проверим ошибки конфигурации:

      • sudo apache2ctl configtest

      Вы должны получить следующий результат:

      Output

      Syntax OK

      Перезапустие Apache для внесения изменений:

      • sudo systemctl restart apache2

      Теперь Apache должен обслуживать ваше доменное имя. Вы можете проверить это, открыв в браузере адрес http://example.com, после чего должны увидеть примерно следующее:

      Пример виртуального хоста Apache

      Шаг 6 — Знакомство с важными файлами и директориями Apache

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

      Контент

      • /var/www/html: веб-контент, в состав которого по умолчанию входит только показанная ранее страница Apache по умолчанию, выводится из каталога /var/www/html. Это можно изменить путем изменения файлов конфигурации Apache.

      Конфигурация сервера

      • /etc/apache2: каталог конфигурации Apache. Здесь хранятся все файлы конфигурации Apache.
      • /etc/apache2/apache2conf: главный файл конфигурации Apache. Его можно изменить для внесения изменений в глобальную конфигурацию Apache. Этот файл отвечает за загрузку многих других файлов в каталоге конфигурации.
      • /etc/apache2/ports.conf: этот файл задает порты, которые будет прослушивать Apache. По умолчанию Apache прослушивает порта 80, а если активирован модуль с функциями SSL, он также прослушивает порт 443.
      • /etc/apache2/sites-available/: каталог, где можно хранить виртуальные хосты для каждого сайта. Apache не будет использовать файлы конфигурации из этого каталога, если они не будут связаны с каталогом sites-enabled. Обычно все изменения конфигурации серверных блоков выполняются в этом каталоге, а затем активируются посредством ссылки на другой каталог с помощью команды a2ensite.
      • /etc/apache2/sites-enabled/: каталог, где хранятся активные виртуальные хосты для каждого сайта. Обычно они создаются посредством создания ссылок на файлы конфигурации из каталога sites-available с помощью команды a2ensite. Apache считывает файлы конфигурации и ссылки из этого каталога при запуске или перезагрузке, когда компилируется полная конфигурация.
      • /etc/apache2/conf-available/, /etc/apache2/conf-enabled/: эти каталоги имеют те же отношения, что и каталоги sites-available и sites-enabled, но используются для хранения фрагментов конфигурации, которые не принадлежат виртуальному хосту. Файлы из каталога conf-available можно активировать с помощью команды a2enconf и отключить с помощью команды a2disconf.
      • /etc/apache2/mods-available/, /etc/apache2/mods-enabled/: эти каталоги содержат доступны и активированные модули соответственно. Файлы с расширением .load содержат фрагменты для загрузки определенных модулей, а файлы с расширением .conf содержат конфигурации этих модулей. Модули можно активировать и отключать с помощью команд a2enmod и a2dismod.

      Журналы сервера

      • /var/log/apache2/access.log: по умолчанию каждый запрос веб-сервера регистрируется в этом файле журналда, если Apache не настроен по другому.
      • /var/log/apache2/error.log: по умолчанию все ошибки регистрируются в этом файле. Директива LogLevel в конфигурации Apache указывает, насколько детальные записи регистрируются в журналах ошибок.

      Заключение

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

      Если вы хотите развернуть более сложный набор обслуживания приложений, ознакомьтесь со статьей Настройка стека LAMP в Ubuntu 20.04.



      Source link

      Создание веб-сервера в Node.js с помощью модуля HTTP


      Автор выбрал COVID-19 Relief Fund для получения пожертвования в рамках программы Write for DOnations.

      Введение

      При просмотре веб-страницы в браузере мы отправляем запрос на другой компьютер в Интернете, который отправляет в ответ веб-страницу. Компьютер, с которым вы взаимодействуете через Интернет, называется веб-сервером. Веб-сервер получает запросы HTTP от клиентов, в том числе от вашего браузера, и отправляет им ответы HTTP, например страницы HTML или код JSON из API.

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

      Node.js позволяет разработчикам использовать JavaScript для создания серверного кода, хотя традиционно этот язык использовался в браузере для создания клиентского кода. Объединение клиентского и серверного кода в одной среде разработки упрощает создание веб-серверов, и именно поэтому Node.js стал популярным инструментом для написания серверного кода.

      В этом обучающем руководстве мы научимся создавать веб-серверы с помощью модуля http, входящего в состав Node.js. Мы создадим веб-серверы, которые смогут возвращать данные JSON, файлы CSV и веб-страницы HTML.

      Предварительные требования

      • Убедитесь, что на используемом для разработки компьютере установлен Node.js. Для целей этого обучающего руководства мы используем версию Node.js 10.19.0. Чтобы установить его в macOS или Ubuntu 18.04, следуйте указаниям руководства Установка Node.js и создание локальной среды разработки в macOS или раздела Установка с помощью PPA руководства Установка Node.js в Ubuntu 18.04.
      • Платформа Node.js позволяет создавать готовые веб-серверы. Для начала вам следует познакомиться с основами Node.js. Для этого вы можете воспользоваться нашим руководством Написание и запуск первой программы на Node.js.
      • Также мы посвятим один из разделов этого обучающего руководства асинхронному программированию. Если вы незнакомы с асинхронным программированием в Node.js или с модулем fs для взаимодействия с файлами, вы можете узнать о них больше из нашей статьи Написание асинхронного кода в Node.js.

      Шаг 1 — Создание базового сервера HTTP

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

      Прежде всего нам нужно настроить доступную среду программирования для выполнения наших упражнений, а также других заданий в настоящей статье. Создайте в терминале папку с именем first-servers:

      Затем откройте эту папку:

      Затем создайте файл для кода:

      Откройте файл в текстовом редакторе. Мы используем редактор nano, потому что он доступен в терминале:

      Для начала мы загрузим модуль http, входящий в стандартную комплектацию установки Node.js. Добавьте следующую строку в hello.js:

      first-servers/hello.js

      const http = require("http");
      

      Модуль http содержит функцию создания сервера, которую мы более детально рассмотрим позднее. Если вы хотите узнать больше о модулях в Node.js, познакомьтесь с нашей статьей Создание модуля Node.js.

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

      first-servers/hello.js

      ...
      const host = 'localhost';
      const port = 8000;
      

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

      Значение localhost — это специальный частный адрес, с помощью которого компьютеры ссылаются на себя. Обычно оно эквивалентно внутреннему IP-адресу 127.0.0.1 и доступно только локальному компьютеру, но недоступно Интернету или локальным сетям, к которым подключен компьютер.

      Порт — это числовое значение, которое серверы используют как точку доступа или «дверь» к нашему IP-адресу. В нашем примере мы будем использовать для нашего веб-сервера порт 8000. Порты 8080 и 8000 обычно используются при разработке как порты по умолчанию, и в большинстве случаев разработчики предпочитают использовать именно эти порты для серверов HTTP.

      Когда мы привяжем наш сервер к этому хосту и порту, мы сможем подключаться к нашему серверу, открывая адрес http://localhost:8000 в локальном браузере.

      Добавим специальную функцию, которую в Node.js мы называем прослушиватель запросов. Эта функция предназначена для обработки входящих запросов HTTP и возврата ответа HTTP. Данная функция должна иметь два аргумента, объект запроса и объект ответа. Объект запроса записывает все данные поступающего запроса HTTP. Объект ответа используется для возвращения серверу ответов HTTP.

      Нам нужно, чтобы наш первый сервер возвращал следующее сообщение при попытке доступа к нему: "My first server!".

      Добавим эту функцию:

      first-servers/hello.js

      ...
      
      const requestListener = function (req, res) {
          res.writeHead(200);
          res.end("My first server!");
      };
      

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

      Все функции прослушивания запросов в Node.js принимают два аргумента, req и res (мы можем присвоить им другие имена, если захотим). Отправляемый пользователем запрос HTTP записывается в объекте Request, который соответствует первому аргументу, req. Отправляемый пользователю ответ HTTP формируется посредством взаимодействия с объектом Response во втором аргументе, res.

      Первая строка res.writeHead(200); задает код состояния HTTP для ответа. Коды состояния HTTP показывают, насколько хорошо запрос HTTP обработан сервером. В данном случае код состояния 200 соответствует результату "OK". Если вы хотите узнать больше о различных кодах HTTP, которые могут возвращать ваши веб-серверы, и о значении этих кодов, начните с нашего руководства Диагностика распространенных кодов ошибок HTTP.

      Следующая строка функции, res.end("My first server!") ;, записывает ответ HTTP на клиент, который его запросил. Эта функция возвращает любые данные, которые должен возвращать сервер. В этом случае будут возвращаться текстовые данные.

      Теперь мы можем создать сервер и использовать прослушиватель запросов:

      first-servers/hello.js

      ...
      
      const server = http.createServer(requestListener);
      server.listen(port, host, () => {
          console.log(`Server is running on http://${host}:${port}`);
      });
      

      Сохраните код и закройте nano, нажав CTRL+X.

      В первой строке мы создали новый объект server с помощью функции createServer() модуля http. Этот сервер принимает запросы HTTP и передает их нашей функции requestListener().

      После создания сервера мы должны привязать его к сетевому адресу. Для этого мы используем метод server.listen(). Он принимает три аргумента: port, host и функцию обратного вызова, срабатывающую, когда сервер начинает прослушивание.

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

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

      Примечание. Хотя requestListener() не использует объект req, он должен быть первым аргументом функции.

      Мы создали веб-сервер, написав менее пятнадцати строк кода. Проверим его работу, запустив программу:

      Мы увидим в консоли следующее:

      Output

      Server is running on http://localhost:8000

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

      Мы используем отдельное окно терминала для взаимодействия с сервером с помощью cURL, инструмента командной строки для обмена данными с сетью. Введите команду для отправки запроса HTTP GET на запущенный нами сервер:

      • curl http://localhost:8000

      При нажатии клавиши ENTER на терминале появится следующее:

      Output

      My first server!

      Мы настроили сервер и получили от него первый ответ.

      Теперь давайте подробнее разберемся с тем, что произошло во время тестирования сервера. Мы использовали cURL для отправки запроса GET на сервер с адресом http://localhost:8000. Наш сервер Node.js прослушивал соединения этого адреса. Сервер передал запрос функции requestListener(). Функция вернула текстовые данные с кодом состояния 200. Сервер отправил ответ в cURL, и на нашем терминале появилось сообщение.

      Прежде чем продолжить, нажмем CTRL+C и закроем запущенный сервер. Это прервет работу сервера и вернет нас в командную строку.

      Большинство сайтов и API не используют для ответов формат обычного текста. Страницы HTML и данные JSON —наиболее распространенные форматы ответов. На следующем шаге мы узнаем, как возвращать ответы HTTP в распространенных форматах данных, которые мы встречаем в Интернете.

      Шаг 2 — Возврат разных типов контента

      Возвращаемый веб-сервером ответ может иметь разные форматы. Мы уже упоминали JSON и HTML, но также существуют и другие текстовые форматы, в том числе XML и CSV. Кроме того, веб-серверы могут возвращать данные и не в текстовом формате, в том числе файлы PDF, архивы zip, аудио- и видеофайлы.

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

      Все эти три типа данных основаны на текстовом формате и очень часто используются для распространения контента в Интернете. Многие инструменты и языки разработки для серверов поддерживают возврат этих типов данных. В контексте Node.js нам необходимы две вещи:

      1. Задать для заголовка Content-Type в ответах HTTP подходящее значение.
      2. Убедиться, что res.end() получает данные в правильном формате.

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

      Создайте новый файл с именем html.js. Этот файл будет использоваться позднее для возврата текста HTML в ответе HTTP. Здесь мы введем код шаблона и скопируем его в другие серверы, возвращающие разные типы.

      Введите в терминале следующее:

      Теперь откройте этот файл в текстовом редакторе:

      Скопируем код шаблона. Введите в nano следующее:

      first-servers/html.js

      const http = require("http");
      
      const host = 'localhost';
      const port = 8000;
      
      const requestListener = function (req, res) {};
      
      const server = http.createServer(requestListener);
      server.listen(port, host, () => {
          console.log(`Server is running on http://${host}:${port}`);
      });
      

      Сохраните файл html.js и закройте его с помощью CTRL+X, а затем вернитесь в терминал.

      Теперь скопируем этот файл в два новых файла. Первый файл будет возвращать данные CSV в ответе HTTP:

      Второй файл будет возвращать ответ JSON на сервере:

      Остальные файлы будут предназначены для последующих упражнений:

      • cp html.js htmlFile.js
      • cp html.js routes.js

      Теперь мы готовы продолжить наши упражнения. Начнем с возврата JSON.

      Вывод JSON

      Нотация объектов JavaScript (JSON) представляет собой текстовый формат обмена данными. Как предполагает его название, данный формат основан на объектах JavaScript, но при этом он не зависит от языка, то есть его может использовать любой язык программирования, способный парсить его синтаксис.

      Формат JSON обычно используется API для приема и возврата данных. Его популярность обусловлена меньшим размером, чем у XML и других форматов обмена данными, а также наличием инструментов для парсинга его синтаксиса без излишних усилий. Если вы хотите узнать больше о JSON, вы можете прочитать наше руководство Работа с JSON в JavaScript.

      Откройте файл json.js с помощью nano:

      Нам нужно вернуть ответ JSON. Изменим функцию requestListener() для возврата соответствующего заголовка для всех ответов JSON посредством изменения выделенных строк:

      first-servers/json.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
      };
      ...
      

      Метод res.setHeader() добавляет заголовок HTTP к ответу. Заголовки HTTP содержат дополнительную информацию, которая может быть прикреплена к запросу или ответу. Метод res.setHeader() принимает два аргумента: название заголовка и его значение.

      Заголовок Content-Type используется для указания формата данных, который также называется типом носителя и отправляется с запросом или ответом. В этом случае Content-Type имеет значение application/json.

      Возвратим пользователю контент JSON. Изменим json.js следующим образом:

      first-servers/json.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
          res.writeHead(200);
          res.end(`{"message": "This is a JSON response"}`);
      };
      ...
      

      Как и ранее, мы сообщаем пользователю об успешном выполнении запроса, возвращая статус 200. Теперь наш аргумент строки в вызове response.end() содержит корректный код JSON.

      Сохраните и закройте json.js, нажав CTRL+X. Запустим сервер с помощью команды node:

      Подключимся к серверу в другом терминале, используя cURL:

      • curl http://localhost:8000

      Нажав ENTER, мы увидим следующий результат:

      Output

      {"message": "This is a JSON response"}

      Нам удалось успешно вывести ответ JSON, как и во многих популярных API для создания приложений. Обязательно закройте работающий сервер, нажав CTRL+C, чтобы вернуться в стандартную командную строку терминала. Теперь перейдем к CSV, другому популярному формату вывода данных.

      Обслуживание CSV

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

      Откройте файл csv.js в нашем рабочем пространстве с помощью текстового редактора:

      Добавим следующие строки в функцию requestListener():

      first-servers/csv.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "text/csv");
          res.setHeader("Content-Disposition", "attachment;filename=oceanpals.csv");
      };
      ...
      

      Теперь Content-Type имеет значение text/csv, соответствующее формату файлов CSV. Также мы добавим заголовок Content-Disposition. Этот заголовок указывает браузеру способ отображения данных, особенно в браузере или в отдельном файле.

      При возврате ответов CSV большинство современных браузеров автоматически загружают файл, даже если заголовок Content-Disposition не установлен. Однако при возврате файла CSV этот заголовок нужно добавить, поскольку он позволяет нам задать имя файла CSV. Мы сообщаем браузеру, что файл CSV является вложением, и что его следует загрузить. Затем мы сообщаем браузеру, что файлу присвоено имя oceanpals.csv.

      Запишем данные CSV в ответе HTTP:

      first-servers/csv.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "text/csv");
          res.setHeader("Content-Disposition", "attachment;filename=oceanpals.csv");
          res.writeHead(200);
          res.end(`id,name,emailn1,Sammy Shark,[email protected]`);
      };
      ...
      

      Как и раньше, мы возвращаем статус 200/OK в нашем ответе. Теперь наш вызов res.end() содержит строку корректного файла CSV. Значения в каждом столбце разделяются запятыми, а строки разделяются символом новой строки (n). У нас имеется две строки, одна для заголовка таблицы, а другая — для данных.

      Протестируем этот сервер в браузере. Сохраните файл csv.js и закройте редактор, нажав CTRL+X.

      Запустите сервер с помощью команды Node.js:

      Откроем сервер в другом терминале с помощью cURL:

      • curl http://localhost:8000

      На консоли появится следующее:

      Output

      id,name,email 1,Sammy Shark,[email protected]

      Если мы откроем в браузере адрес http://localhost:8000, загрузится файл CSV. Файл будет иметь имя oceanpals.csv.

      Закройте работающий сервер, нажав CTRL+C для возврата в стандартную командную строку терминала.

      Мы рассмотрели возврат данных в форматах JSON и CSV, которые часто используются в API. Теперь перейдем к возврату данных сайтов, просматриваемых людьми в браузере.

      Обслуживание кода HTML

      Гипертекстовый язык разметки (HTML) — самый распространенный формат, используемый пользователями при взаимодействии с серверами через браузер. Он был создан для структурирования веб-контента. Браузеры разработаны для отображения контента в формате HTML, оформленного с использованием стилей CSS, еще одной клиентской веб-технологии для настройки внешнего вида сайтов.

      Откроем файл html.js в текстовом редакторе еще раз:

      Изменим функцию requestListener() так, чтобы она возвращала подходящий заголовок Content-Type для ответа HTML:

      first-servers/html.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "text/html");
      };
      ...
      

      Возвратим пользователю контент HTML. Добавьте в файл html.js выделенные строки, чтобы он выглядел следующим образом:

      first-servers/html.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "text/html");
          res.writeHead(200);
          res.end(`<html><body><h1>This is HTML</h1></body></html>`);
      };
      ...
      

      Вначале мы добавляем код состояния HTTP. Затем мы вызываем response.end() с аргументом строки, содержащим корректный код HTML. Открывая сервер в браузере, мы увидим страницу HTML с одним тегом заголовка со значением This is HTML.

      Сохраним файл и закроем редактор, нажав CTRL+X. Запустим сервер с помощью команды node:

      После запуска программы мы увидим сообщение Server is running on http://localhost:8000.

      Откройте в браузере адрес http://localhost:8000. Страница будет выглядеть следующим образом:

      Изображение ответа HTML, возвращаемого сервером Node.js

      Закроем работающий сервер, нажав CTRL+C для возврата в стандартную командную строку терминала.

      Код HTML часто добавляется в файл отдельно от серверного кода, такого как наши программы Node.js. Посмотрим, как можно выводить ответы HTML из файлов.

      Шаг 3 — Вывод страницы HTML из файла

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

      Для вывода файлов HTML мы загружаем их с помощью модуля fs и используем их данные при написании ответа HTTP.

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

      Откройте файл index.html в текстовом редакторе:

      Наша веб-страница будет минимальной. Она будет иметь оранжевый фон и содержать текст приветствия в центре. Добавьте в файл следующий код:

      first-servers/index.html

      <!DOCTYPE html>
      
      <head>
          <title>My Website</title>
          <style>
              *,
              html {
                  margin: 0;
                  padding: 0;
                  border: 0;
              }
      
              html {
                  width: 100%;
                  height: 100%;
              }
      
              body {
                  width: 100%;
                  height: 100%;
                  position: relative;
                  background-color: rgb(236, 152, 42);
              }
      
              .center {
                  width: 100%;
                  height: 50%;
                  margin: 0;
                  position: absolute;
                  top: 50%;
                  left: 50%;
                  transform: translate(-50%, -50%);
                  color: white;
                  font-family: "Trebuchet MS", Helvetica, sans-serif;
                  text-align: center;
              }
      
              h1 {
                  font-size: 144px;
              }
      
              p {
                  font-size: 64px;
              }
          </style>
      </head>
      
      <body>
          <div class="center">
              <h1>Hello Again!</h1>
              <p>This is served from a file</p>
          </div>
      </body>
      
      </html>
      

      На этой веб-странице отображается две строки текста: Hello Again! и This is served from a file. Строки отображаются друг над другом в центре страницы. Первая строка текста отображается как заголовок, то есть она будет больше. Вторая строка текста будет немного меньше. Весь текст будет выводиться белым цветом на оранжевом фоне страницы.

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

      Это весь код HTML, который нам нужен, так что теперь можно сохранить и закрыть файл, нажав CTRL+X. Теперь мы можем перейти к коду сервера.

      В этом упражнении мы будем работать с файлом htmlFile.js. Откройте этот файл в текстовом редакторе:

      Поскольку нам нужно прочитать файл, для начала импортируем модуль fs:

      first-servers/htmlFile.js

      const http = require("http");
      const fs = require('fs').promises;
      ...
      

      Этот модуль содержит функцию readFile(), которую мы будем использовать для загрузки файла HTML. Мы импортируем вариант обещания в соответствии с современными передовыми практиками работы с JavaScript. Мы используем обещания, поскольку с синтаксической точки зрения они лучше функций обратного вызова, к которым нам пришлось бы прибегнуть, если бы мы назначили fs как require('fs'). Дополнительную информацию о лучших практиках асинхронного программирования можно найти в нашем руководстве Написание асинхронного кода в Node.js.

      Нам нужно, чтобы при отправке пользователем запроса к системе считывался наш файл HTML. Для начала изменим requestListener() для чтения файла:

      first-servers/htmlFile.js

      ...
      const requestListener = function (req, res) {
          fs.readFile(__dirname + "/index.html")
      };
      ...
      

      Мы используем метод fs.readFile() для загрузки файла. Он использует аргумент __dirname + "/index.html". Специальная переменная __dirname содержит абсолютный путь к директории запуска кода Node.js. В конце мы добавляем /index.html, чтобы мы могли загрузить ранее созданный файл HTML.

      Возвратим страницу HTML после ее загрузки:

      first-servers/htmlFile.js

      ...
      const requestListener = function (req, res) {
          fs.readFile(__dirname + "/index.html")
              .then(contents => {
                  res.setHeader("Content-Type", "text/html");
                  res.writeHead(200);
                  res.end(contents);
              })
      };
      ...
      

      Если обещание fs.readFile() успешно выполняется, оно возвращает свои данные. Для этого случая мы используем метод then(). Параметр contents содержит данные файла HTML.

      Вначале мы задаем для заголовка Content-Type значение text/html, чтобы сообщить клиенту, что мы возвращаем данные HTML. Затем мы пишем код состояния, показывая, что запрос выполнен успешно. В заключение мы отправляем на клиент загруженную страницу HTML с данными в переменной contents.

      Иногда метод fs.readFile() может выполняться с ошибками, и нам нужно предусмотреть подобные случаи. Добавьте в функцию requestListener() следующее:

      first-servers/htmlFile.js

      ...
      const requestListener = function (req, res) {
          fs.readFile(__dirname + "/index.html")
              .then(contents => {
                  res.setHeader("Content-Type", "text/html");
                  res.writeHead(200);
                  res.end(contents);
              })
              .catch(err => {
                  res.writeHead(500);
                  res.end(err);
                  return;
              });
      };
      ...
      

      Сохраните файл и закройте nano, нажав CTRL+X.

      Когда в обещании возникает ошибка, оно отклоняется. Эта ситуация обрабатывается с помощью метода catch(). Он принимает ошибку, возвращаемую fs.readFile(), устанавливает код состояния 500, сигнализирующий о внутренней ошибке, и возвращает пользователю сообщение об ошибке.

      Запустите наш сервер с помощью команды node:

      Откройте в браузере адрес http://localhost:8000. Вы увидите следующую страницу:

      Изображение страницы HTML, загруженной из файла в Node.js

      Мы вывели пользователю страницу HTML с сервера. Теперь мы можем закрыть запущенный сервер, нажав CTRL+C. Сделав это, мы увидим командную строку терминала.

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

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

      Эффективный вывод кода HTML

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

      Откройте в терминале скрипт Node.js с помощью текстового редактора:

      Добавим новую переменную, прежде чем создавать функцию requestListener():

      first-servers/htmlFile.js

      ...
      let indexFile;
      
      const requestListener = function (req, res) {
      ...
      

      При запуске программы эта переменная будет хранить содержимое файла HTML.

      Изменим функцию requestListener(). Теперь вместо загрузки файла она будет возвращать содержимое indexFile:

      first-servers/htmlFile.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "text/html");
          res.writeHead(200);
          res.end(indexFile);
      };
      ...
      

      Далее мы изменим логику чтения файла с функции requestListener() на момент запуска нашего сервера. Внесите следующие изменения при создании сервера:

      first-servers/htmlFile.js

      ...
      
      const server = http.createServer(requestListener);
      
      fs.readFile(__dirname + "/index.html")
          .then(contents => {
              indexFile = contents;
              server.listen(port, host, () => {
                  console.log(`Server is running on http://${host}:${port}`);
              });
          })
          .catch(err => {
              console.error(`Could not read index.html file: ${err}`);
              process.exit(1);
          });
      

      Сохраните файл и закройте nano, нажав CTRL+X.

      Код, считывающий файл, похож на написанный нами при первой попытке. Однако при успешном чтении файла мы можем сохранить его содержимое в глобальной переменной indexFile. Мы запустим сервер с методом listen(). Главное — загрузить файл до запуска сервера. Так функция requestListener() гарантированно возвращает страницу HTML, поскольку переменная indexFile больше не пустая.

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

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

      Шаг 4 — Управление маршрутами с использованием объекта HTTP Request

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

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

      Создадим новый сервер для небольшой библиотеки, который будет возвращать два разных типа данных. Если пользователь откроет адрес сервера с /books, он получит список книг в формате JSON. Если пользователь откроет раздел /authors, он получит список с информацией об авторах в формате JSON.

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

      Запустим заново наш пример с ответом JSON:

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

      • curl http://localhost:8000

      Вы увидите следующее:

      Output

      {"message": "This is a JSON response"}

      Теперь попробуем другую команду curl:

      • curl http://localhost:8000/todos

      После нажатия Enter вы увидите тот же самый результат:

      Output

      {"message": "This is a JSON response"}

      Мы не встраивали в функцию requestListener() никакую специальную логику дял обработки запроса, URL которого содержит /todos, и поэтому Node.js по умолчанию возвращает то же сообщение JSON.

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

      Для начала закройте сервер, нажав CTRL+C.

      Откройте файл routes.js в своем текстовом редакторе:

      Начнем с сохранения наших данных JSON в переменных перед функцией requestListener():

      first-servers/routes.js

      ...
      const books = JSON.stringify([
          { title: "The Alchemist", author: "Paulo Coelho", year: 1988 },
          { title: "The Prophet", author: "Kahlil Gibran", year: 1923 }
      ]);
      
      const authors = JSON.stringify([
          { name: "Paulo Coelho", countryOfBirth: "Brazil", yearOfBirth: 1947 },
          { name: "Kahlil Gibran", countryOfBirth: "Lebanon", yearOfBirth: 1883 }
      ]);
      ...
      

      Переменная books — это строка, содержащая данные JSON для массива объектов книг. Каждая книга имеет заголовок или название, автора и год издания.

      Переменная authors — это строка, содержащая данные JSON для массива объектов авторов. Каждый автор имеет имя, страну рождения и год рождения.

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

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

      first-servers/routes.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
      }
      ...
      

      Далее нам нужно возвращать подходящие данные JSON в зависимости от URL, используемого пользователем. Создадим выражение switch для URL запроса:

      first-servers/routes.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
          switch (req.url) {}
      }
      ...
      

      Чтобы получить путь URL от объекта request, нам потребуется доступ к его свойству url. Теперь мы можем добавить в выражение switch варианты для возврата подходящего кода JSON.

      Выражение switch в JavaScript позволяет определять, какой код будет выполняться в зависимости от значения объекта или выражения JavaScript (например, от результата математической операции). Если вы не знаете или забыли, как использовать такие выражения, воспользуйтесь нашим руководством Использование выражения switch в JavaScript.

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

      first-servers/routes.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
          switch (req.url) {
              case "/books":
                  res.writeHead(200);
                  res.end(books);
                  break
          }
      }
      ...
      

      Мы устанавливаем код состояния 200, указывая, что запрос обработан правильно, и возвращаем данные JSON, содержащие список книг. Добавим еще один вариант для авторов:

      first-servers/routes.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
          switch (req.url) {
              case "/books":
                  res.writeHead(200);
                  res.end(books);
                  break
              case "/authors":
                  res.writeHead(200);
                  res.end(authors);
                  break
          }
      }
      ...
      

      Как и раньше, мы используем код состояния 200 для подтверждения правильного выполнения запроса. Теперь мы возвращаем данные JSON со списком авторов.

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

      routes.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
          switch (req.url) {
              case "/books":
                  res.writeHead(200);
                  res.end(books);
                  break
              case "/authors":
                  res.writeHead(200);
                  res.end(authors);
                  break
              default:
                  res.writeHead(404);
                  res.end(JSON.stringify({error:"Resource not found"}));
          }
      }
      ...
      

      Мы используем ключевое слово default в выражении switch, чтобы учесть все остальные сценарии, кроме описанных в предыдущих вариантах. Мы устанавливаем код состояния 404, указывающий, что запрошенный URL не найден. Далее мы задаем объект JSON, содержащий сообщение об ошибке.

      Протестируем поведение нашего сервера. Запустите на другом терминале команду, чтобы проверить, получим ли мы список книг:

      • curl http://localhost:8000/books

      Нажмите Enter, чтобы получить следующий результат:

      Output

      [{"title":"The Alchemist","author":"Paulo Coelho","year":1988},{"title":"The Prophet","author":"Kahlil Gibran","year":1923}]

      Пока все хорошо. Попробуем то же самое для /authors. Введите в терминале следующую команду:

      • curl http://localhost:8000/authors

      После выполнения команды вы увидите следующее:

      Output

      [{"name":"Paulo Coelho","countryOfBirth":"Brazil","yearOfBirth":1947},{"name":"Kahlil Gibran","countryOfBirth":"Lebanon","yearOfBirth":1883}]

      В заключение попробуем ввести ошибочный URL, чтобы функция requestListener() вывела сообщение об ошибке:

      • curl http://localhost:8000/notreal

      При вводе этой команды будет выведено следующее сообщение:

      Output

      {"error":"Resource not found"}

      Закройте работающий сервер, нажав CTRL+C.

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

      Заключение

      В этом обучающем руководстве мы создали несколько серверов HTTP Node.js. Вначале мы сформировали простой текстовый ответ. Затем мы перешли к возврату с сервера разных типов данных: JSON, CSV и HTML. Затем мы рассмотрели комбинирование загрузки файлов с ответами HTTP для вывода пользователю страниц HTML с сервера и создания API, использующего данные запроса пользователя для определения ответа.

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

      Чтобы узнать больше о веб-серверах HTTP в Node.js, вы можете почитать документацию Node.js по модулю http. Если вы хотите продолжить изучение Node.js, возвращайтесь на страницу серии Программирование в Node.js.



      Source link

      Установка веб-сервера OpenLiteSpeed в Ubuntu 18.04


      Введение

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

      В этом руководстве мы расскажем, как установить и настроить OpenLiteSpeed на сервере Ubuntu 18.04.

      Предварительные требования

      Для выполнения этого обучающего руководства вам потребуется сервер Ubuntu 18.04 с пользователем без прав root и привилегиями sudo, а также активированный брандмауэр ufw.

      См. руководство по первоначальной настройке сервера с Ubuntu 18.04 для получения инструкций по выполнению этих требований.

      Шаг 1 — Установка OpenLiteSpeed

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

      Чтобы активировать этот репозиторий для вашей системы Ubuntu, сначала загрузите и добавьте ключ подписи ПО для разработчика:

      • wget -qO - https://rpms.litespeedtech.com/debian/lst_repo.gpg | sudo apt-key add -

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

      Далее мы добавим в нашу систему информацию о репозитории:

      • sudo add-apt-repository 'deb http://rpms.litespeedtech.com/debian/ bionic main'

      После добавления репозитория команда add-apt-repository обновит наш кэш пакетов и новое программное обеспечение будет доступно для установки.

      Установите сервер OpenLiteSpeed и его процессор PHP с помощью apt install:

      • sudo apt install openlitespeed lsphp73

      Создайте гибкую ссылку на процессор PHP, который мы только что установили. Она указывает, что сервер OpenLiteSpeed будет использовать правильную версию:

      • sudo ln -sf /usr/local/lsws/lsphp73/bin/lsphp /usr/local/lsws/fcgi-bin/lsphp5

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

      Шаг 2 — Настройка пароля администратора

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

      • sudo /usr/local/lsws/admin/misc/admpass.sh

      Вам будет предложено предоставить имя пользователя для администратора. Если вы нажмете ENTER без выбора нового имени пользователя, будет использоваться имя admin по умолчанию. Затем вам будет предложено создать и подтвердить новый пароль для учетной записи. Сделайте это, а затем нажмите ENTER последний раз. Скрипт подтвердит успешное обновление:

      Output

      Administrator's username/password is updated successfully!

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

      Шаг 3 — Запуск и подключение к серверу

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

      • sudo /usr/local/lsws/bin/lswsctrl status

      Output

      litespeed is running with PID 990.

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

      • sudo /usr/local/lsws/bin/lswsctrl start

      Output

      [OK] litespeed: pid=5137.

      Теперь сервер должен быть запущен. Прежде чем мы сможем посетить его в браузере, нам нужно открыть ряд портов в брандмауэре. Мы выполним это с помощью команды ufw:

      • sudo ufw allow 8088
      • sudo ufw allow 7080

      Первый порт 8088 — это порт по умолчанию для примера сайта OpenLiteSpeed. Теперь он должен быть доступен для публики. В браузере укажите доменное имя или IP-адрес вашего сервера, добавив :8088, чтобы указать порт:

      http://server_domain_or_IP:8088
      

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

      скриншот демо-страницы OpenLiteSpeed по умолчанию

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

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

      https://server_domain_or_IP:7080
      

      Скорее всего вы увидите предупреждение о том, что сертификат SSL сервера не может быть проверен. Поскольку это самоподписанный сертификат, это ожидаемое поведение. Понажимайте на доступные опции, чтобы перейти к сайту. В Chrome вы должны нажать «Advanced», а затем «Proceed to…».

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

      скриншот страницы входа администратора OpenLiteSpeed

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

      скриншот панели администратора OpenLiteSpeed

      Здесь вы сможете задать большинство параметров конфигурации веб-сервера.

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

      Шаг 4 — Изменение порта для страницы по умолчанию

      Чтобы продемонстрировать процесс настройки опций через веб-интерфейс, мы изменим порт, который использует сайт по умолчанию, с 8088 на используемый HTTP стандартный порт 80.

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

      В списке обработчиков событий нажмите кнопку View/Edit для обработчика Default:

      скриншот страницы общей информации для обработчика событий OpenLiteSpeed

      В результате откроется страница с подробной информацией об обработчике событий с именем Default. Нажмите кнопку редактирования в правом верхнем углу таблицы Address Settings, чтобы изменить его значения:

      скриншот страницы информации обработчика событий OpenLiteSpeed

      На следующем экране замените порт 8088 на порт 80, а затем нажмите значок дискеты, Save:

      скриншот интерфейса обновления обработчика событий OpenLiteSpeed

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

      кнопка мягкого перезапуска

      Также вам нужно будет открыть порт 80 в брандмауэре:

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

      Заключение

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

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

      • Все файлы, связанные с OpenLiteSpeed, можно найти в директории /usr/local/lsws.
      • Корневая директория документов (откуда будут обслуживаться файлы) для виртуального хоста по умолчанию расположена по адресу /usr/local/lsws/DEFAULT/html. Файлы конфигурации и логи для этого виртуального хоста можно найти в директории /usr/local/lsws/DEFAULT.
      • Вы можете создать новые виртуальные хосты для разных сайтов, используя интерфейс администратора. Однако все директории, на которые вы будете ссылаться при настройке, должны быть созданы предварительно на вашем сервере. OpenLiteSpeed не может создавать директории.
      • Вы можете создать шаблоны виртуального хоста для использования одного общего формата.
      • Часто проще всего скопировать структуру директорий виртуального хоста и конфигурацию для использования в качестве отправной точки для новых конфигураций.
      • Интерфейс администратора имеет встроенную систему подсказок практически для всех полей. Также в левом меню есть пункт меню Help, привязанный к документации сервера. Используйте эти источники информации во время настройки, если вам потребуется дополнительная помощь.
      • Чтобы обеспечить безопасность установки OpenLiteSpeed с помощью HTTPS, ознакомьтесь с разделом официальной документации, посвященным настройке SSL.

      К настоящему моменту на вашем сервере Ubuntu 18.04 должны быть установлены и запущены OpenLiteSpeed и PHP. OpenLiteSpeed позволяет использовать производительный веб-интерфейс конфигурации и предварительно настроенные опции для работы со скриптами.



      Source link