Deployment i Optymalizacja aplikacji w NestJS

NestJS to popularny framework, który ułatwia budowanie serwerowych aplikacji Node.js, oferując strukturalne podejście zorientowane na moduly, kontrolery i serwisy. Po stworzeniu aplikacji w NestJS, koniecznym krokiem jest jej wdrożenie oraz optymalizacja, aby zapewnić niezawodność, szybkość i skalowalność. W tym artykule omówimy jak wykonać deployment aplikacji NestJS oraz jak ją optymalizować pod kątem wydajności.

Deployment aplikacji NestJS

1. Budowanie aplikacji do wdrożenia

Zanim zaczniemy wdrażanie aplikacji, musimy ją zbudować. Proces budowania aplikacji NestJS polega na kompilacji TypeScript do JavaScript, tak aby mogła być uruchomiona na serwerze.

Aby zbudować aplikację NestJS, używamy następującej komendy:

				
					npm run build

Ta komenda używa narzędzia TypeScript Compiler (tsc) do przekonwertowania kodu z TypeScript na JavaScript, tworząc katalog dist, który zawiera gotowy do wdrożenia kod aplikacji. Teraz mamy przygotowaną wersję naszej aplikacji, którą można wdrożyć na serwer.

2. Platformy chmurowe: Heroku, AWS, DigitalOcean

Wdrożenie aplikacji na platformę chmurową to kolejny krok. Poniżej omówimy trzy popularne platformy:

a) Heroku

Heroku jest popularnym wyborem, ponieważ upraszcza proces wdrażania dzięki podejściu Git push. Aby wdrożyć aplikację NestJS na Heroku, wykonujemy następujące kroki:

  1. Zaloguj się na Heroku:

				
					heroku login
  1. Inicjalizacja aplikacji: Jeśli masz repozytorium Git, użyj komendy:
				
					heroku create
  1. Dodaj zmienne środowiskowe:
    Możesz dodać zmienne środowiskowe za pomocą Heroku Dashboard lub komendy:
				
					heroku config:set NODE_ENV=production
  1. Deploy na Heroku: Użyj polecenia Git push:
				
					git push heroku main

b) AWS (Amazon Web Services)

AWS oferuje szereg usług, takich jak EC2 do hostingu aplikacji. Aby wdrożyć aplikację na AWS EC2, musimy:

  1. Utworzyć instancję EC2.

  2. Zainstalować Node.js i skopiować pliki aplikacji na serwer.

  3. Zainstalować zależności:

				
					npm install
  1. Uruchomić aplikację:
				
					npm run start:prod

c) DigitalOcean

DigitalOcean oferuje łatwy sposób na utworzenie dropletu, który będzie służył do uruchomienia aplikacji NestJS. Proces jest podobny jak w AWS, z tym że DigitalOcean również oferuje zautomatyzowane rozwiązania do wdrażania, takie jak App Platform.

3. Tworzenie kontenerów Docker dla aplikacji NestJS

Docker umożliwia pakowanie aplikacji wraz z jej zależnościami w kontener, co zapewnia jej przenośność i możliwość uruchamiania na dowolnej platformie. Oto, jak stworzyć kontener dla aplikacji NestJS:

  1. Stwórz plik Dockerfile:

				
					# Używamy oficjalnego obrazu Node.js
FROM node:14

# Ustawiamy katalog roboczy
WORKDIR /app

# Kopiujemy pliki package.json i package-lock.json
COPY package*.json ./

# Instalujemy zależności
RUN npm install

# Kopiujemy resztę kodu źródłowego
COPY . .

# Budujemy aplikację
RUN npm run build

# Otwieramy port 3000
EXPOSE 3000

# Uruchamiamy aplikację
CMD ["npm", "run", "start:prod"]
  1. Budowanie obrazu Dockera:
				
					docker build -t nestjs-app .
  1. Uruchomienie kontenera:
				
					docker run -p 3000:3000 nestjs-app

Powyższe kroki tworzą kontener, który może być uruchomiony na dowolnym serwerze z zainstalowanym Dockerem.

Optymalizacja aplikacji NestJS

1. Redis do cachingu

Redis to szybka baza danych typu klucz-wartość, która idealnie nadaje się do cachingu. Możemy użyć Redis do przechowywania wyników drogich operacji, co znacząco przyspieszy aplikację.

Przykład użycia Redis w NestJS:

  1. Instalacja Redis i klienta Redis:

				
					npm install cache-manager cache-manager-redis-store
npm install redis
  1. Konfiguracja w module NestJS:
				
					import { CacheModule, Module } from '@nestjs/common';
import * as redisStore from 'cache-manager-redis-store';

@Module({
  imports: [
    CacheModule.register({
      store: redisStore,
      host: 'localhost',
      port: 6379,
    }),
  ],
})
export class AppModule {}

Powyższa konfiguracja ustawia Redis jako backend dla mechanizmu cachingu w NestJS. Możemy teraz cachować odpowiedzi, co zmniejszy obciążenie serwera.

2. Monitorowanie aplikacji i obsługa błędów

Aby aplikacja była stabilna i szybka, ważne jest monitorowanie jej działania. Możemy użyć narzędzi takich jak Prometheus, Grafana lub Sentry.

Przykład integracji Sentry:

  1. Instalacja Sentry:

				
					npm install @sentry/node
  1. Konfiguracja Sentry w aplikacji:
				
					import * as Sentry from '@sentry/node';

Sentry.init({
  dsn: 'YOUR_SENTRY_DSN',
});

Teraz wszystkie błędy będą raportowane do Sentry, co pozwoli nam szybko reagować na potencjalne problemy.

3. Dobre praktyki związane z optymalizacją wydajności

Aby zoptymalizować aplikację, warto przestrzegać kilku dobrych praktyk:

  1. Lazy Loading modułów: Zamiast ładować wszystkie moduły na starcie aplikacji, można załadować tylko te, które są aktualnie potrzebne.

				
					@Module({
  imports: [
    // Moduł ładowany tylko w razie potrzeby
    forwardRef(() => UsersModule),
  ],
})
export class AppModule {}
  1. Używanie nestjs/bull do obsługi zadań w tle: Jeśli w aplikacji występują długotrwałe zadania, warto je przenieść do kolejki, używając biblioteki Bull i Redis.
  2. Kompresja odpowiedzi: Możemy zainstalować middleware compression:
				
					npm install compression

I zaimportować go w głównym pliku aplikacji:

				
					import * as compression from 'compression';

app.use(compression());

Kompresja zmniejszy rozmiar przesyłanych odpowiedzi, co poprawi czas ładowania.

Podsumowanie

Wdrożenie i optymalizacja aplikacji w NestJS to kluczowe kroki w cyklu życia aplikacji. Omówiliśmy jak przygotować aplikację do wdrożenia, jakie platformy chmurowe są dostępne, jak tworzyć kontenery Docker oraz jak wdrożyć Redis do cachingu. Przedstawiliśmy także sposoby monitorowania aplikacji i dbania o jej stabilność. Dzięki tym narzędziom i technikom, Twoja aplikacja NestJS będzie nie tylko działać, ale i działać szybko oraz niezawodnie.

Pamiętaj, że optymalizacja to ciągły proces, a każde wdrożenie to nowe wyzwanie, które uczy nas, jak usprawniać i skalować aplikację na przyszłość.

Kategorie