Jak utworzyć interfejs API RESTful dla Node.js przy użyciu Express.js na Ubuntu 16.04 LTS

• Instalowanie listonosza
• Instalowanie Node.js
• Inicjalizacja naszego projektu Node.js
• Konfigurowanie Express.js
• Rozpoczęcie naszego głównego pliku
• Testowanie naszego API za pomocą Postmana
• Trasy API
• Wprowadzenie do NGINX
• Konfigurowanie NGINX
• Najpierw uruchom z NGINX
• Utrzymywanie działania naszego interfejsu API
• Zarządzanie naszą aplikacją za pomocą PM2
• Uwagi końcowe

W tym samouczku dowiesz się, jak skonfigurować kompletny interfejs API RESTful, który będzie obsługiwał żądania HTTP przy użyciu Node.js i Express, jednocześnie odwracając proxy przy użyciu NGINX na Ubuntu 16.04 LTS. Będziemy korzystać z aplikacji o nazwie Postman, bardzo dobrze znane narzędzie programistyczne API do testowania naszego API i upewnienia się, że jest w pełni funkcjonalny i działa poprawnie. Node.js to szybka, wieloplatformowa platforma JavaScript oparta na silniku Chrome V8. Jest używany zarówno w aplikacjach stacjonarnych, jak i serwerowych i słynie z obsługi jednowątkowej pętli zdarzeń. Będziemy używać Node.js jako backendu dla naszego RESTful API, dołączonego do Express.js, naszej struktury aplikacji internetowych zbudowanej dla Node.js. Express.js został wydany jako bezpłatne i otwarte oprogramowanie. Express jest po stronie serwera, napisany w JavaScript i jest przeznaczony do tworzenia interfejsów API, co czyni go idealnym dla naszego projektu. Z drugiej strony Postman jest bardzo potężnym klientem HTTP z myślą o rozwoju API. Zawiera wszystkie narzędzia, których możesz potrzebować do programowania API.

Instalowanie listonosza

Najpierw chcesz udać się na stronę Postmana oraz pobrać i zainstalować Postmana na swój główny komputer (nie serwer). Wszystkie instrukcje instalacji będą na ich stronie internetowej.

Instalowanie Node.js

Aby rozpocząć, najpierw musimy zainstalować Node.js, abyśmy mogli zacząć rozwijać nasz interfejs API. Będziemy pobierać i instalować Node.js z oficjalnej strony.

 curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -
 sudo apt-get install -y nodejs

Ponadto będziesz chciał pobrać niezbędne narzędzia do budowania, które będą pomocne w kompilowaniu modułów.

sudo apt-get install build-essential

W tym samouczku będziemy używać wersji Lode Node.js, czyli wersji 8.9.3.

Inicjalizacja naszego projektu Node.js

Będziemy musieli zainicjować nowy projekt Node.js, który będzie zawierał aplikację. Aby to zrobić, utwórz nowy katalog.

 mkdir expressapi 

Przejdź do nowego katalogu. Po wejściu do środka uruchom npm initi wypełnij wszystkie wymagane monity. Zwróć uwagę na „punkt wejścia” aplikacji: ten plik zostanie utworzony później. Po zakończeniu zobaczysz package.jsonplik w bieżącym katalogu. Działa jako opis naszego projektu i zawiera listę wszystkich zależności potrzebnych do funkcjonowania.

Konfigurowanie Express.js

Teraz skonfigurujemy Express.js i jego zależności.

npm install express

Rozpocznie się proces instalacji. Pobieranie zajmie kilka minut.

Rozpoczęcie naszego głównego pliku

Następnie utworzymy główny plik początkowy dla naszego interfejsu API. Tutaj użyjesz „punktu wejścia”, który widziałeś w package.jsonpliku. W trosce o tym tutorialu będę używał domyślnego schematu nazewnictwa, index.js.

touch index.js

Następnie otwórz go w nano edytorze tekstu.

nano index.js

W naszym głównym pliku chcemy najpierw wywołać wszystkie nasze główne pakiety i zarejestrować nasze trasy.

var express = require('express');        
var app = express();                 
var bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
var port = process.env.PORT || 8080;  
const router = express.Router();
router.get('/', function(req, res) {
    res.json({ message: 'API is Online!' });   
});

app.use('/api', router);
app.listen(port);
console.log('Listening on port ' + port);

Zasadniczo to, co robimy tutaj, to inicjowanie naszej aplikacji i konfigurowanie podstawowego routera dla naszego interfejsu API. Pamiętaj, że ustawiliśmy port naszej aplikacji na 8080. Będziemy potrzebować tego numeru do konfiguracji naszego interfejsu API RESTful. Teraz jesteśmy gotowi do przetestowania naszego API.

Testowanie naszego API za pomocą Postmana

W katalogu projektu uruchom następujące polecenie.

node <filename>.js

Spowoduje to uruchomienie interfejsu API, gdzie <filename>jest plik początkowy określony w package.jsonpliku. Następnie otwórz Listonosza na komputerze PC / Mac i kliknij przycisk „ New” w prawym górnym rogu, a następnie kliknij przycisk „ Request”. Gdy tam się pojawi, GETobok niego powinien pojawić się pasek „ ”. Tutaj wprowadzimy adres URL naszego żądania. Wystarczy wpisać następujące dane w sekcji adresu URL żądania i kliknąć „ Send”.

`http://your-server-ip:3000/api` 

Zobaczysz „ 'API is online'”.

Trasy API

Do obsługi tras będziemy używać routera Express. Jeśli nie wiesz, co to jest router, to zasadniczo sposób, w jaki punkty końcowe aplikacji odpowiadają na żądania klientów. Oto trasy, które będziemy ustawiać jako przykład:

• /api/numbers - Pokazuje wszystkie liczby od 1-10.

• /api/letters - Pokazuje wszystkie litery od AZ.

Teraz skonfigurujemy naszą strukturę pośrednią pierwszej trasy, taką jak ta.

router.use(function(req, res, next) {
   console.log('We've got something.');
   next() //calls next middleware in the application.
});

router.route('/numbers/:number').get((req, res) => {
     res.json({result: req.params.number + 1})
});

W tym przykładzie ustawiliśmy sytuację, w której użytkownik może zażądać sumy liczby + 1, podając jej formę słowa, używając metody GET. Używamy router.route()funkcji, aby wskazać, jaki numer chcemy odesłać w wyniku. Parametry są nazywane :przed nimi „ ”. Dostęp do tych parametrów uzyskujemy poprzez req.params.

Oto przykład z literami.

   router.route('/letters/:letter').get((req, res) => {
     res.json({result: req.params.letter.toUpperCase()})
});

Używamy tej samej metody, co powyżej, ale wysyłamy list z wielkimi literami.

Wprowadzenie do NGINX

NGINX jest dobrze znanym oprogramowaniem typu open source używanym do udostępniania stron internetowych, odwrotnych serwerów proxy, przesyłania strumieniowego i innych. Będziemy wykorzystywać NGINX do odwracania proxy naszego API, aby umożliwić nam uruchomienie go na porcie 80, ponieważ Node.js nie zezwala na połączenia na portach mniejszych niż 1024 bez dostępu root. Może to być przydatne podczas łączenia domeny z serwerem.

Konfigurowanie NGINX

Aby rozpocząć instalację NGINX, musisz uruchomić następujące polecenia w terminalu i poczekać na zakończenie instalacji.

sudo apt-get install nginx

Następnie będziemy chcieli utworzyć nasz plik strony, którego NGINX użyje do odwrócenia proxy naszej aplikacji.

sudo nano /etc/nginx/sites-available-api.js

Wypełnij plik, a następnie CTRL+, Oaby go zapisać.

server {
          listen 80;
          location / {
                proxy_set_header X-Real-IP 
                $remote_addr;
                proxy_set_header 
                X-Forwarded-For 
                $proxy_add_x_forwarded_for;
                proxy_set_header Host 
                $http_host;
                proxy_set_header 
                X-NginX-Proxy true; proxy_pass 
                http://127.0.0.1:8080/;
                proxy_redirect off;
                proxy_http_version 1.1;
                proxy_set_header Upgrade 
                $http_upgrade;
                proxy_set_header Connection 
                "upgrade";
                proxy_redirect off;
                proxy_set_header 
               X-Forwarded-Proto $scheme;
       }
}

Korzystając z tego samego portu, na którym wcześniej uruchomiliśmy naszą aplikację, mówimy Nginx, aby przekierowywał wszystkie żądania z naszego adresu IP na porcie 80do naszego API działającego na porcie 8080.

Następnie włącz odwrotne proxy poprzez symlinkowanie naszego nowo utworzonego pliku do sites-availablefolderu:

sudo ln -s /etc/nginx/sites-available/api /etc/nginx/sites-available

Zapewni to, że NGINX odwróci proxy naszego API.

Najpierw uruchom z NGINX

Po zakończeniu konfiguracji NGINX uruchomimy NGINX, a następnie uruchomimy API. Najpierw uruchom ponownie NGINX.

sudo systemctl restart nginx

Następnie wróć do katalogu API i uruchom go.

node <filename>.js

Aplikacja będzie działać na porcie 80. Po prostu uruchom test z góry za pomocą Postmana, aby upewnić się, że wszystko działa poprawnie.

Utrzymywanie działania naszego interfejsu API

W środowisku produkcyjnym chcesz się upewnić, że masz menedżera procesów dla aplikacji Node, aby zapewnić, że będą one działały wiecznie w tle. W tym samouczku będziemy używać menedżera procesów o nazwie PM2 (Process Manager 2), który jest menedżerem procesów dla aplikacji Node.js, który utrzyma je przy życiu na zawsze przy minimalnym przestoju. PM2 zawiera wiele przydatnych narzędzi do zarządzania, takich jak zatrzymywanie, przeładowywanie, wstrzymywanie i wiele innych. Aby zainstalować PM2, wpisz następujące polecenie i poczekaj na jego zainstalowanie.

sudo npm install pm2 -g

Po zainstalowaniu wystarczy upewnić się, że znajdujesz się w katalogu projektu, wpisz następujące polecenie, a aplikacja zostanie uruchomiona.

pm2 start <filename>.js

Zarządzanie naszą aplikacją za pomocą PM2

Jak wspomniano wcześniej, PM2 ma kilka przydatnych narzędzi, których można użyć do lepszego zarządzania aplikacją.

• pm2 stop- Jak sama nazwa wskazuje, pozwala to zatrzymać aktualnie uruchomioną aplikację i zabić jej proces. Jeśli aplikacja generuje nieoczekiwany wynik, zatrzymanie jej przyda się.

• pm2 list- Funkcja listy pozwala zobaczyć wszystkie aktualnie uruchomione aplikacje przez PM2, zamapowane według ich nazw. Jeśli chcesz szybko sprawdzić czas działania aplikacji, powinieneś użyć tego narzędzia.

• pm2 restart- Jeśli aplikacja z jakiegoś powodu zawiesza się i chcesz ją ponownie załadować, restart pm2 właśnie to robi. Zabije proces aplikacji i uruchom go ponownie w ramach innego procesu.

• pm2 monit- Wbudowane narzędzie PM2 do monitorowania pozwala wyświetlić wykres szczegółowych informacji o aplikacji, takich jak użycie procesora / pamięci RAM, na przyjaznym dla użytkownika wykresie w stylu ncurses. Jest to przydatne, jeśli chcesz uzyskać obraz obciążenia aplikacji.

Uwagi końcowe

Zakończyliśmy teraz nasze zadanie tworzenia interfejsu API RESTful przy użyciu Node.js, Express i odwrotnego proxy w NGINX. Rozwiń ten samouczek. Za pomocą nowego interfejsu API możesz robić wiele wspaniałych rzeczy, takich jak dodawanie metod uwierzytelniania, baza danych, lepsza obsługa tras i błędów oraz wiele, wiele więcej. Jeśli masz domenę z już ustawionym rekordem „A” na adres IP, będziesz mógł uzyskać dostęp do interfejsu API ze swojej domeny. Jeśli chcesz dowiedzieć się więcej o Express.js, odwiedź ich stronę internetową http://expressjs.com . Aby dowiedzieć się więcej o NGINX i odwrotnym proxy, odwiedź http://nginx.com . Aby dowiedzieć się więcej o PM2, odwiedź ich stronę pod adresem http://pm2.keymetrics.io .