One place for hosting & domains

      для

      Использование .map() для итерации элементов массива в JavaScript


      Введение

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

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

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

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

      Шаг 1 — Вызов функции для каждого элемента массива

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

      Приведем пример:

      const sweetArray = [2, 3, 4, 5, 35]
      const sweeterArray = sweetArray.map(sweetItem => {
          return sweetItem * 2
      })
      
      console.log(sweeterArray)
      

      Вывод регистрируется в консоли:

      Output

      [ 4, 6, 8, 10, 70 ]

      Это можно упростить еще больше для очистки кода:

      // create a function to use
      const makeSweeter = sweetItem => sweetItem * 2;
      
      // we have an array
      const sweetArray = [2, 3, 4, 5, 35];
      
      // call the function we made. more readable
      const sweeterArray = sweetArray.map(makeSweeter);
      
      console.log(sweeterArray);
      

      Этот же вывод регистрируется в консоли:

      Output

      [ 4, 6, 8, 10, 70 ]

      Использование выражений вида sweetArray.map(makeSweeter) делает код более удобочитаемым.

      Шаг 2 — Конвертация строки в массив

      Метод .map() принадлежит к прототипу массива. На этом шаге мы используем его для конвертации строки в массив. Здесь мы не разрабатываем метод для работы со строками. Вместо этого мы используем специальный метод .call().

      В JavaScript все элементы являются объектами, и к этим объектам прикреплены методы и функции. Метод .call() позволяет использовать контекст одного объекта с другим объектом. Поэтому вы скопируете контекст .map() в массив на строке.

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

      Приведем пример:

      const name = "Sammy"
      const map = Array.prototype.map
      
      const newName = map.call(name, eachLetter => {
          return `${eachLetter}a`
      })
      
      console.log(newName)
      

      Вывод регистрируется в консоли:

      Output

      • [ "Sa", "aa", "ma", "ma", "ya" ]

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

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

      Шаг 3 — Рендеринг списков в библиотеках JavaScript

      Библиотеки JavaScript, такие как React, используют метод .map() для рендеринга элементов в списках. Однако для этого требуется синтаксис JSX, поскольку метод .map() заключен в синтаксис JSX.

      Приведем пример компонента React:

      import React from "react";
      import ReactDOM from "react-dom";
      
      const names = ["whale", "squid", "turtle", "coral", "starfish"];
      
      const NamesList = () => (
        <div>
          <ul>{names.map(name => <li key={name}> {name} </li>)}</ul>
        </div>
      );
      
      const rootElement = document.getElementById("root");
      ReactDOM.render(<NamesList />, rootElement);
      

      Это компонент React без состояния, выполняющий рендеринг div со списком. Рендеринг отдельных элементов списка выполняется посредством использования метода .map() для итерации по именам, изначально созданным массивом. Рендеринг этого компонента выполняется с использованием ReactDOM на элементе DOM с Id root.

      Шаг 4 — Переформатирование объектов массива

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

      Приведем пример:

      const myUsers = [
          { name: 'shark', likes: 'ocean' },
          { name: 'turtle', likes: 'pond' },
          { name: 'otter', likes: 'fish biscuits' }
      ]
      
      const usersByLikes = myUsers.map(item => {
          const container = {};
      
          container[item.name] = item.likes;
          container.age = item.name.length * 10;
      
          return container;
      })
      
      console.log(usersByLikes);
      

      Вывод регистрируется в консоли:

      Output

      [ {shark: "ocean", age: 50}, {turtle: "pond", age: 60}, {otter: "fish biscuits", age: 50} ]

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

      Заключение

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



      Source link

      Использование EJS для преобразования приложения Node в шаблон


      Введение

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

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

      Настройка демонстрационного приложения

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

      Получите код: Репозиторий git с полным кодом демонстрации можно найти на GitHub здесь.

      Структура файлов

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

      - views
      ----- partials
      ---------- footer.ejs
      ---------- head.ejs
      ---------- header.ejs
      ----- pages
      ---------- index.ejs
      ---------- about.ejs
      - package.json
      - server.js
      

      package.json будет содержать информацию нашего приложения Node и необходимые нам зависимости (express и EJS), а server.js будет содержать настройку, конфигурацию сервера Express. Здесь мы определим маршруты к нашим страницам.

      Настройка узла

      Давайте откроем файл package.json и настроим в нем наш проект.

      package.json

      {
        "name": "node-ejs",
        "main": "server.js",
        "dependencies": {
          "ejs": "^3.1.5",
          "express": "^4.17.1"
        }
      }
      

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

      Установив все зависимости, настроим приложение для использования EJS и настроим маршруты для двух страниц, которые нам нужны: страницы индекса (полная ширина) и информационной страницы (боковая панель). Мы будем делать это в файле server.js.

      server.js

      // load the things we need
      var express = require('express');
      var app = express();
      
      // set the view engine to ejs
      app.set('view engine', 'ejs');
      
      // use res.render to load up an ejs view file
      
      // index page
      app.get("https://www.digitalocean.com/", function(req, res) {
          res.render('pages/index');
      });
      
      // about page
      app.get('/about', function(req, res) {
          res.render('pages/about');
      });
      
      app.listen(8080);
      console.log('8080 is the magic port');
      

      Здесь мы определим наше приложение и зададим для него отображение на порту 8080. Также нам нужно задать EJS как механизм просмотра для нашего приложения Express с помощью app.set('view engine', 'ejs'); Обратите внимание, как мы отправляем представление пользователю, используя res.render(). Важно отметить, что res.render() будет искать представление в папке views. Это значит, что нам нужно определить только pages/index, поскольку полный путь выглядит как views/pages/index.

      Запуск сервера

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

      Теперь мы можем открыть наше приложение в браузере, используя адреса http://localhost:8080 и http://localhost:8080/about. Мы настроили наше приложение, и нам нужно определить файлы представления и посмотреть, как EJS работает с ними.

      Создание частичных элементов EJS

      Как и в других приложениях здесь будет много кода, используемого многократно. Мы назовем такие элементы частичными шаблонами и определим три файла, которые будут использоваться везде на нашем сайте: head.ejs, header.ejs и footer.ejs. Создадим эти файлы.

      views/partials/head.ejs

      <meta charset="UTF-8">
      <title>EJS Is Fun</title>
      
      <!-- CSS (load bootstrap from a CDN) -->
      <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.5.2/css/bootstrap.min.css">
      <style>
          body { padding-top:50px; }
      </style>
      

      views/partials/header.ejs

      <nav class="navbar navbar-expand-lg navbar-light bg-light">
        <a class="navbar-brand" href="https://www.digitalocean.com/">EJS Is Fun</a>
        <ul class="navbar-nav mr-auto">
          <li class="nav-item">
            <a class="nav-link" href="https://www.digitalocean.com/">Home</a>
          </li>
          <li class="nav-item">
            <a class="nav-link" href="http://www.digitalocean.com/about">About</a>
          </li>
        </ul>
      </nav>
      

      views/partials/footer.ejs

      <p class="text-center text-muted">© Copyright 2020 The Awesome People</p>
      

      Добавление частичных шаблонов EJS в представления

      Итак, мы определили частичные шаблоны. Теперь нужно добавить их в наши представления. Возьмем файлы index.ejs и about.ejs и используем синтаксис include для добавления частичных шаблонов.

      Синтаксис добавления частичного шаблона EJS

      Используйте <%- include('RELATIVE/PATH/TO/FILE') %>, чтобы встроить частичный шаблон EJS в другой файл.

      • Дефис <%- вместо <% предписывает EJS выполнять рендеринг необработанного кода HTML.
      • Путь к частичному шаблону является относительным по отношению к текущему файлу.

      views/pages/index.ejs

      <!DOCTYPE html>
      <html lang="en">
      <head>
          <%- include('../partials/head'); %>
      </head>
      <body class="container">
      
      <header>
          <%- include('../partials/header'); %>
      </header>
      
      <main>
          <div class="jumbotron">
              <h1>This is great</h1>
              <p>Welcome to templating using EJS</p>
          </div>
      </main>
      
      <footer>
          <%- include('../partials/footer'); %>
      </footer>
      
      </body>
      </html>
      

      Теперь мы можем посмотреть определенное представление в браузере по адресу http://localhost:8080. node-ejs-templating-index

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

      views/pages/about.ejs

      <!DOCTYPE html>
      <html lang="en">
      <head>
          <%- include('../partials/head'); %>
      </head>
      <body class="container">
      
      <header>
          <%- include('../partials/header'); %>
      </header>
      
      <main>
      <div class="row">
          <div class="col-sm-8">
              <div class="jumbotron">
                  <h1>This is great</h1>
                  <p>Welcome to templating using EJS</p>
              </div>
          </div>
      
          <div class="col-sm-4">
              <div class="well">
                  <h3>Look I'm A Sidebar!</h3>
              </div>
          </div>
      
      </div>
      </main>
      
      <footer>
          <%- include('../partials/footer'); %>
      </footer>
      
      </body>
      </html>
      

      Если мы откроем адрес http://localhost:8080/about, мы увидим нашу информационную страницу с боковой панелью! node-ejs-templating-about

      Теперь мы можем начать использовать EJS для передачи данных из нашего приложения Node в наши представления.

      Передача данных в представления и частичные шаблоны

      Определим некоторые базовые переменные и список для передачи на главную страницу. Вернитесь в файл server.js и добавьте следующий код в маршрут app.get("https://www.digitalocean.com/").

      server.js

      // index page
      app.get("https://www.digitalocean.com/", function(req, res) {
          var mascots = [
              { name: 'Sammy', organization: "DigitalOcean", birth_year: 2012},
              { name: 'Tux', organization: "Linux", birth_year: 1996},
              { name: 'Moby Dock', organization: "Docker", birth_year: 2013}
          ];
          var tagline = "No programming concept is complete without a cute animal mascot.";
      
          res.render('pages/index', {
              mascots: mascots,
              tagline: tagline
          });
      });
      

      Мы создали список mascots и простую строку tagline. Теперь перейдем в файл index.ejs и используем их.

      Рендеринг одиночной переменной в EJS

      Чтобы отразить через эхо одну переменную, мы просто используем <%= tagline %>. Добавим этот код в наш файл index.ejs:

      views/pages/index.ejs

      ...
      <h2>Variable</h2>
      <p><%= tagline %></p>
      ...
      

      Циклический перебор данных в EJS

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

      views/pages/index.ejs

      ...
      <ul>
          <% mascots.forEach(function(mascot) { %>
              <li>
                  <strong><%= mascot.name %></strong>
                  representing <%= mascot.organization %>, born <%= mascot.birth_year %>
              </li>
          <% }); %>
      </ul>
      ...
      

      Теперь мы можем видеть в браузере новую информацию, которую мы добавили!

      node-ejs-templating-rendered

      Передача данных в частичный шаблон в EJS

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

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

      views/pages/about.ejs

      ...
      <header>
          <%- include('../partials/header', {variant:'compact'}); %>
      </header>
      ...
      

      При этом нужно с осторожностью предполагать, что переменная определена.

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

      views/partials/header.ejs

      ...
      <em>Variant: <%= typeof variant != 'undefined' ? variant : 'default' %></em>
      ...
      

      В строке выше код EJS выполняет рендеринг значения variant, если оно определено, и default, если не определено.

      Заключение

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

      Дополнительную справку по EJS можно найти в официальной документации здесь.



      Source link

      Настройка удаленного доступа для MongoDB в Ubuntu 20.04


      Предыдущая версия данного руководства была написана Мелиссой Андерсон.

      Введение

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

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

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

      Для завершения данного обучающего модуля вам потребуется:

      • Сервер на базе Ubuntu 20.04. На сервере должен быть пользователь без привилегий root с правами администратора и брандмауэр, настроенный с помощью UFW. Вы можете выполнить настройку, следуя указаниям руководства Начальная настройка сервера для Ubuntu 20.04.
      • MongoDB, установленная на сервере. Данное обучающее руководство предполагает, что у вас уже установлена MongoDB версии 4.4 или более новой. Вы можете установить эту версию, следуя указаниям руководства Установка MongoDB в Ubuntu 20.04.
      • Второй компьютер, с которого вы получите доступ к вашему экземпляру MongoDB. Для простоты в данном руководстве мы будем считать, что этот компьютер — это еще один сервер Ubuntu 20.04 с пользователем без привилегий root и правами администратора и брандмауэром UFW, настроенным в соответствии с руководством Начальная настройка сервера Ubuntu 20.04. Однако шаги 1 и 2, которые описывают фактическую процедуру обеспечения удаленного подключения на сервере базы данных, можно выполнять независимо от используемой операционной системы удаленного компьютера.

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

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

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

      Для начала проверьте порт, на котором прослушивается ваша система MongoDB, с помощью команды lsof. Эта команда обычно возвращает список со всеми открытыми файлами в системе, но при сочетании с опцией -i она указывает только сетевые файлы или потоки данных.

      Следующая команда перенаправляет вывод команды lsof -i на команду grep, которая ищет строку с именем mongo:

      • sudo lsof -i | grep mongo

      Этот пример вывода показывает, что MongoDB прослушивает подключения на порту по умолчанию 27017:

      Output

      mongod 82221 mongodb 11u IPv4 913411 0t0 TCP localhost:27017 (LISTEN)

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

      Запустите следующую команду, убедившись, что вы поменяли trusted_server_ip на IP-адрес доверенного удаленного компьютера, который вы будете использовать для доступа к вашему экземпляру MongoDB:

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

      • sudo ufw allow from trusted_server_ip to any port 27017

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

      Вы можете проверить изменение параметров брандмауэра с помощью ufw:

      Вывод покажет, что трафик к порту 27017 с удаленного сервера сейчас разрешен:

      Output

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

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

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

      Шаг 2 — Настройка публичного bindIP

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

      Чтобы разрешить удаленные подключения, необходимо отредактировать файл конфигурации MongoDB — /etc/mongod.conf — для дополнительной привязки MongoDB к публичному маршрутизированному IP-адресу вашего сервера. Таким образом ваша система MongoDB сможет прослушивать подключения к вашему серверу MongoDB, выполненные с удаленных компьютеров.

      Откройте файл конфигурации MongoDB в предпочитаемом текстовом редакторе. В следующем примере используется nano:

      • sudo nano /etc/mongod.conf

      Найдите раздел network interfaces (сетевые интерфейсы), а затем значение bindIp:

      /etc/mongod.conf

      . . .
      # network interfaces
      net:
        port: 27017
        bindIp: 127.0.0.1
      
      . . .
      

      Добавьте запятую в эту строку, а затем публичный IP-адрес вашего сервера MongoDB:

      /etc/mongod.conf

      . . .
      # network interfaces
      net:
        port: 27017
        bindIp: 127.0.0.1,mongodb_server_ip
      
      . . .
      

      Сохраните и закройте файл. Если вы используете nano, нажмите CTRL+X, Y, затем ENTER.

      Затем перезапустите MongoDB, чтобы изменение вступило в силу:

      • sudo systemctl restart mongod

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

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

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

      Примечание. Как указано в разделе «Предварительные требования», это обучающее руководство предполагает, что ваш удаленный компьютер — это еще один сервер на базе Ubuntu 20.04. Процедура по обеспечению удаленных подключений, описанная в шагах 1 и 2, должна работать независимо от операционной системы вашего удаленного компьютера. Однако методы тестирования, описанные в этом шаге, не являются универсальными для всех операционных систем.

      Один из способов проверки возможности подключения вашего доверенного удаленного сервера к экземпляру MongoDB — это использование команды nc. nc (сокращенно от netcat) — это утилита, используемая для установки сетевых подключений с TCP или UDP. Она используется для тестирования в подобных случаях, поскольку позволяет вам указать как IP-адрес, так и номер порта.

      Вначале войдите на ваш доверенный сервер с помощью SSH:

      • ssh sammy@trusted_server_ip

      Затем запустите команду nc, которая включает опцию -z. Это ограничивает nc только сканированием прослушивающего демона на целевом сервере без отправки каких-либо данных. Напомним из руководства по установке, что MongoDB работает как служебный демон, что делает эту опцию полезной для тестирования подключения. Также она включает опцию v, которая увеличивает детализацию команды, благодаря чему netcat возвращает некоторые выводы, которые иначе не были бы получены.

      Запустите следующую команду nc с вашего доверенного удаленного сервера и не забудьте заменить mongodb_server_ip IP-адресом сервера, на котором вы установили MongoDB:

      • nc -zv mongodb_server_ip 27017

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

      Output

      Connection to mongodb_server_ip 27017 port [tcp/*] succeeded!

      Если вы установили совместимую версию оболочки mongo на вашем удаленном сервере, вы можете на данном этапе подключаться напрямую к экземпляру MongoDB, установленному на сервере хоста.

      Одним из способов подключения является URI строки подключения, например:

      • mongo "mongodb://mongo_server_ip:27017"

      Примечание. Если вы выполнили рекомендации из руководства Обеспечение безопасности MongoDB в Ubuntu 20.04, у вас будет закрыт доступ к вашей базе данных от пользователей, которые не прошли аутентификацию. В этом случае вам нужно будет использовать URI с указанием действительного имени пользователя, например:

      • mongo "mongodb://username@mongo_server_ip:27017"

      Оболочка автоматически попросит ввести пароль пользователя.

      Этим вы подтверждаете, что ваш сервер MongoDB может принимать соединения с доверенного сервера.

      Заключение

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

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



      Source link