Jak dokeryzować interfejs API REST Node.js

Proces wdrażania i uruchamiania aplikacji w różnych środowiskach może być kłopotliwy, ponieważ należy wziąć pod uwagę wiele czynników takie jak konfigurowanie zmiennych środowiskowych w celu skonfigurowania niezbędnych zależności i określonych wersji różnych pakietów oprogramowania.

Jednak wykorzystując technologię konteneryzacji Dockera, możesz wdrażać aplikacje w różnych środowiskach przy minimalnym wysiłku ze wszystkimi niezbędnymi zależnościami w obrazie dokera. Oznacza to, że nie musisz się martwić o jakąkolwiek konfigurację. Dzięki temu proces wdrażania i uruchamiania aplikacji w różnych środowiskach jest dziecinnie prosty.

Co to jest Docker?

Doker to platforma programistyczna, która zapewnia narzędzia i środowisko do pakowania aplikacji w postaci przenośnych obrazów, które można uruchamiać jako niezależne komponenty wykonywalne w kontenerach.

Kontenery te stanowią kod aplikacji i wymagane zależności, aby aplikacja działała pomyślnie w różnych środowiskach wykonawczych bez żadnych problemów.

Zanim zaczniesz, zainstaluj Dockera na komputerze lokalnym. Sprawdź wymagania wstępne dotyczące platformy i instrukcje instalacji z oficjalnej dokumentacji.

Utwórz interfejs API REST Node.js

Rozpocząć, utwórz serwer WWW Node.js.

Możesz znaleźć kod tej aplikacji w jej Repozytorium GitHub.

Następnie zainstaluj wymagane pakiety dla tego projektu.

npm zainstaluj morgan pg knex

The str pakiet służy do nawiązania połączenia z bazą danych PostgreSQL. kneks, z drugiej strony, zapewnia prosty interfejs API do interakcji z PostgreSQL — użyjesz go do pisania zapytań SQL.

Na koniec użyjesz Morgana, oprogramowanie pośrednie, które rejestruje żądania HTTP i odpowiedzi na konsoli, aby debugować i monitorować aplikację działającą w kontenerze Docker.

Na koniec otwórz indeks.js plik i dodaj kod poniżej implementuje proste API REST z trzema trasami.

konst ekspres = wymagać("wyrazić")
konst Morgana = wymagać(„morgana”)
konst aplikacja = ekspres()
konst baza danych = wymagać('./db')
konst PORT = proces.env. PORT || 5000
app.use (morgan(„deweloper”))
app.use (express.json())
app.use (express.urlencoded({ rozszerzony: PRAWDA }))
aplikacja.pobierz('/', (req, res) => res.send('Witaj świecie!' ))
aplikacja.pobierz('/użytkownicy', asynchroniczny (wymaganie, res) => {
konst użytkownicy = czekać na db.select().from(„użytkownicy”)
 res.json (użytkownicy)
})
aplikacja.post('/użytkownicy', asynchroniczny (wymaganie, res) => {
konst użytkownik = czekać na baza danych („użytkownicy”).wstawić({ nazwa: req.body.name }).returning('*')
 res.json (użytkownik)
})
app.listen (PORT, () => konsola.dziennik(`Serwer w PORT:${PORT}`))

Skonfiguruj połączenie z bazą danych

Interfejs API REST będzie współdziałał z instancją PostgreSQL Dockera, jednak najpierw musisz skonfigurować połączenie z bazą danych w swojej aplikacji. W katalogu głównym folderu projektu utwórz plik db.js plik i dodaj poniższy kod.

konst kneks = wymagać(„kneks”)
moduł.eksport = knex({
 klient: 'postgres',
 połączenie: {
 gospodarz: „db”,
 użytkownik: „użytkownik testowy”,
 hasło: „mojehasło123”,
 Baza danych: „użytkownik testowy”,

 },
})

Skonfiguruj pliki migrate.js i seed.js

Te dwa pliki umożliwią utworzenie tabeli w bazie danych i wypełnienie jej danymi testowymi za pośrednictwem API. Stworzyć nowy folder, skrypty, w katalogu głównym projektu i dodaj dwa pliki: migracja.js I seed.js.

w migracja.js plik, dodaj poniższy kod:

konst baza danych = wymagać('../db');
(asynchroniczny () => {
próbować {
czekać na db.schema.dropTableIfExists(„użytkownicy”)
czekać na db.schemat.withSchema('publiczny'.createTable(„użytkownicy”, (tabela) => {
 table.increments()
 tabela.string('nazwa')
 })
konsola.dziennik(„Utworzono tabelę użytkowników!”)
 proces.wyjście(0)
 } złapać (błąd) {
konsola.log (błąd)
 proces.wyjście(1)
 }
})()

Ten kod utworzy plik użytkownicy table z automatycznie rosnącą kolumną id i a nazwa kolumna w bazie danych.

Dalej, w seed.js plik, dodaj poniższy kod:

konst baza danych = wymagać('../db');
(asynchroniczny () => {
próbować {
czekać na baza danych („użytkownicy”).wstawić({ nazwa: „Użytkownik testowy 1” })
czekać na baza danych („użytkownicy”).wstawić({ nazwa: „Użytkownik testowy 2” })
konsola.dziennik(„Dodano fałszywych użytkowników!”)
 proces.wyjście(0)
 } złapać (błąd) {
konsola.log (błąd)
 proces.wyjście(1)
 }
})()

Ten kod implementuje funkcję asynchroniczną, która wstawi dwóch użytkowników do bazy danych PostgreSQL.

Na koniec dodaj te polecenia do swojego pakiet.json plik.

„skrypty”: {
"początek": „indeks węzła.js”,
"migrować": „skrypty węzłów/migracja.js”,
"nasionko": „skrypty węzłów/seed.js”
 },

Ponieważ nie masz skonfigurowanego klienta, aby przetestować interfejs API, będziesz musiał uruchomić dwa pliki jako skrypty obok bieg npm Komenda.

Skonfiguruj plik Docker

Plik Docker definiuje instrukcje wymagane przez silnik Docker do zbudowania obrazu Docker. W katalogu głównym projektu utwórz nowy plik i nadaj mu nazwę, Plik dokera. Następnie dodaj poniższe instrukcje, aby utworzyć obraz platformy Docker dla aplikacji Node.js.

Z węzeł:16.3.0-alpejski3.13
KIEROW.ROB /app
KOPIUJ pakiet*.json ./
URUCHOMIĆ instalacja npm
KOPIUJ. .
UJAWNIĆ8000
CMD [ "węzeł", „index.js” ]

Rozbijmy to na czynniki pierwsze:

• Z — Ta instrukcja ustawia obraz podstawowy dla aplikacji, którym jest obraz Node.js Alpine, uproszczona wersja obrazu Node.js, którą można znaleźć w rejestrze platformy Docker.
• KIEROW.ROB - zestawy /app katalog jako katalog roboczy.
• KOPIUJ pakiet*.json./ - instruuje Dockera, aby skopiował wszystkie pliki w tym formacie nazwy pliku z bieżącego katalogu do /app teczka.
• URUCHOMIĆ - wykonuje i buduje wizerunek.
• KOPIUJ.. - kopiuje pliki źródłowe do /app teczka.
• UJAWNIĆ - instruuje to Dockera, aby udostępnił port w kontenerze środowisku zewnętrznemu, w tym przypadku maszynie hosta.
• CMD - określa polecenie, które ma zostać wykonane, gdy kontener Docker jest tworzony z obrazu.

Utwórz plik Docker Compose

Aby aplikacja Node.js mogła współdziałać z instancją Docker PostgreSQL, obie aplikacje muszą działać w kontenerach Docker w tym samym środowisku sieciowym.

Z tego powodu należy zdefiniować i zbudować zarówno obraz aplikacji, jak i instancję PostgreSQL za pomocą Tworzenie Dockera — narzędzie, które pozwala budować i zarządzać wieloma kontenerami Docker.

Mówiąc najprościej, za pomocą Docker Compose możesz zdefiniować usługi tworzące aplikację jako pojedynczą jednostkę, w tym przypadku API REST Node.js i bazę danych PostgreSQL.

Utwórz nowy plik, docker-compose.yml, w katalogu głównym i dodaj poniższy kod:

wersja:'3.9'
usługi:
serwer:
zbudować:.
porty:
-'5000:5000'
zależy od:
-baza danych
baza danych:
obraz:'postgres'
porty:
-'4321:5432'
środowisko:
POSTGRES_PASSWORD:„mojehasło123”
POSTGRES_USER:„użytkownik testowy”
wolumeny:
-dane:/var/lib/postgresql/data
wolumeny:
dane:

Ten kod utworzy i uruchomi dwa kontenery Docker. Pierwszy kontener, serwer, Docker Compose używa pliku Dockerfile do zbudowania obrazu dla tego kontenera.

Określa również, że kontener serwera zależy od baza danych pojemnik. Znaczenie, serwer kontener musi zostać uruchomiony po baza danych kontener, aby się z nim połączyć.

Drugi kontener to kontener bazy danych PostgreSQL. Nie musisz określać pliku Dockerfile dla tego kontenera, ponieważ zostanie on utworzony z obrazu PostgreSQL w rejestrze obrazów Dockera.

Zbuduj obrazy Dockera

Użyj polecenia Docker Compose, aby skompilować obrazy i uruchomić dwa kontenery.

tworzenie dokerów -d

Po pomyślnym zakończeniu procesu powinieneś zobaczyć podobną odpowiedź.

Przetestuj interfejs API REST

Uruchom poniższe polecenie, aby przetestować interfejs API REST działający w kontenerze platformy Docker. Powinien utworzyć tabelę w bazie danych PostgreSQL.

docker exec docker_node-server-1 npm uruchom migrację

Powinieneś zobaczyć podobną odpowiedź.

Udostępnianie obrazów Dockera

Ostatnim krokiem jest wypchnięcie obrazu platformy Docker dla Twojej aplikacji Node.js do Docker Hub. Jest to podobne do wypychania projektów do GitHub.

• Udaj się do Centrum Dockera i załóż konto i zaloguj się do panelu użytkownika.
• Następnie kliknij Utwórz repozytorium. Podaj nazwę swojego repozytorium i ustaw jego widoczność na dowolną Publiczny Lub Prywatny a następnie kliknij Tworzyć.
• Aby przesłać obraz Dockera swojej aplikacji do Docker Hub, musisz najpierw zalogować się na swoje konto przez terminal, a następnie podać swoją nazwę użytkownika i hasło.

logowanie dokera

• Następnie zaktualizuj nazwę obrazu Dockera, aby pasowała do tego formatu: /. Uruchom poniższe polecenie, aby wprowadzić tę zmianę:

 znacznik dokera /

• Na koniec wypchnij obraz platformy Docker.

 wypychanie dokera /< nazwa repozytorium>

Używanie Dockera w programowaniu

Ten przewodnik poruszył tylko ułamek potencjału, jaki może zaoferować Docker. Jednak teraz możesz użyć technologii konteneryzacji Dockera do spakowania dowolnej aplikacji i wszystkich jej zależności jako obrazy, które można wdrażać w różnych środowiskach programistycznych, a także produkcyjnych, takich jak chmura bez żadnych czkawka.