Практика: Next.js + NestJS + PostgreSQL + Redis

nest new api
npx create-next-app@latest web

cd api
npm install pg ioredis

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  await app.listen(process.env.PORT || 3001, '0.0.0.0');
}

bootstrap();

import { Module } from '@nestjs/common';
import { StatusController } from './status/status.controller';
import { StatusService } from './status/status.service';

@Module({
  controllers: [StatusController],
  providers: [StatusService],
})
export class AppModule {}

import { Controller, Get } from '@nestjs/common';
import { StatusService } from './status.service';

@Controller('status')
export class StatusController {
  constructor(private readonly statusService: StatusService) {}

  @Get()
  getStatus() {
    return this.statusService.getStatus();
  }
}

import { Injectable, OnModuleDestroy } from '@nestjs/common';
import { Pool } from 'pg';
import Redis from 'ioredis';

@Injectable()
export class StatusService implements OnModuleDestroy {
  private readonly database = new Pool({
    connectionString: process.env.DATABASE_URL,
  });

  private readonly redis = new Redis(
    process.env.REDIS_URL || 'redis://localhost:6379',
  );

  async getStatus() {
    const databaseResult = await this.database.query('SELECT NOW() AS now');

    await this.redis.set('last_status_check', new Date().toISOString());

    const lastStatusCheck = await this.redis.get('last_status_check');

    return {
      api: 'ok',
      postgres: {
        connected: true,
        serverTime: databaseResult.rows[0].now,
      },
      redis: {
        connected: true,
        lastStatusCheck,
      },
    };
  }

  async onModuleDestroy() {
    await this.database.end();
    await this.redis.quit();
  }
}

postgresql://app:app_password@postgres:5432/app

redis://redis:6379

{
  "scripts": {
    "build": "nest build",
    "start": "node dist/main",
    "start:dev": "nest start --watch"
  }
}

'use client';

import { useEffect, useState } from 'react';

export default function HomePage() {
  const [status, setStatus] = useState(null);
  const [error, setError] = useState(null);

  useEffect(() => {
    fetch(`${process.env.NEXT_PUBLIC_API_URL}/status`)
      .then((response) => {
        if (!response.ok) {
          throw new Error('API повернув помилку');
        }

        return response.json();
      })
      .then(setStatus)
      .catch((requestError) => {
        setError(requestError.message);
      });
  }, []);

  return (
    <main style={{ padding: 32, fontFamily: 'sans-serif' }}>
      <h1>Next.js + NestJS + PostgreSQL + Redis</h1>

      {error && <p>Помилка: {error}</p>}

      {!status && !error && <p>Завантаження...</p>}

      {status && (
        <pre>{JSON.stringify(status, null, 2)}</pre>
      )}
    </main>
  );
}

http://localhost:3001

FROM node:22-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci

COPY . .

EXPOSE 3001

CMD ["npm", "run", "start:dev"]

FROM node:22-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci

COPY . .

EXPOSE 3000

CMD ["npm", "run", "dev"]

services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: app
      POSTGRES_USER: app
      POSTGRES_PASSWORD: app_password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - backend
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d app"]
      interval: 5s
      timeout: 5s
      retries: 10

  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis_data:/data
    networks:
      - backend
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 10

  api:
    build:
      context: ./api
      dockerfile: Dockerfile
    environment:
      PORT: 3001
      DATABASE_URL: postgresql://app:app_password@postgres:5432/app
      REDIS_URL: redis://redis:6379
    ports:
      - "3001:3001"
    networks:
      - backend
      - frontend
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy

  web:
    build:
      context: ./web
      dockerfile: Dockerfile
      args:
        NEXT_PUBLIC_API_URL: http://localhost:3001
    environment:
      NEXT_PUBLIC_API_URL: http://localhost:3001
    ports:
      - "3000:3000"
    networks:
      - frontend
    depends_on:
      - api

volumes:
  postgres_data:
  redis_data:

networks:
  backend:
    driver: bridge
  frontend:
    driver: bridge

volumes:
  postgres_data:
  redis_data:

docker compose down

docker compose down -v

services:
  api:
    volumes:
      - ./api:/app
      - api_node_modules:/app/node_modules
    command: npm run start:dev

  web:
    volumes:
      - ./web:/app
      - web_node_modules:/app/node_modules
      - web_next:/app/.next
    command: npm run dev

volumes:
  api_node_modules:
  web_node_modules:
  web_next:

- ./api:/app

docker compose -f compose.yaml -f compose.dev.yaml up --build

docker compose -f compose.yaml -f compose.dev.yaml up --build -d

docker compose -f compose.yaml -f compose.dev.yaml logs -f

docker compose -f compose.yaml -f compose.dev.yaml logs -f api

docker compose -f compose.yaml -f compose.dev.yaml down

FROM node:22-alpine AS build

WORKDIR /app

COPY package*.json ./
RUN npm ci

COPY . .
RUN npm run build

FROM node:22-alpine AS production

WORKDIR /app

ENV NODE_ENV=production

COPY package*.json ./
RUN npm ci --omit=dev

COPY --from=build /app/dist ./dist

EXPOSE 3001

CMD ["node", "dist/main"]

/** @type {import('next').NextConfig} */
const nextConfig = {
  output: 'standalone',
};

module.exports = nextConfig;

FROM node:22-alpine AS build

WORKDIR /app

ARG NEXT_PUBLIC_API_URL
ENV NEXT_PUBLIC_API_URL=$NEXT_PUBLIC_API_URL

COPY package*.json ./
RUN npm ci

COPY . .
RUN npm run build

FROM node:22-alpine AS production

WORKDIR /app

ENV NODE_ENV=production
ENV PORT=3000
ENV HOSTNAME=0.0.0.0

COPY --from=build /app/public ./public
COPY --from=build /app/.next/standalone ./
COPY --from=build /app/.next/static ./.next/static

EXPOSE 3000

CMD ["node", "server.js"]

services:
  api:
    build:
      context: ./api
      dockerfile: Dockerfile.prod
    environment:
      NODE_ENV: production
    command: node dist/main

  web:
    build:
      context: ./web
      dockerfile: Dockerfile.prod
      args:
        NEXT_PUBLIC_API_URL: http://localhost:3001
    environment:
      NODE_ENV: production
    command: node server.js

docker compose -f compose.yaml -f compose.prod.yaml up --build -d

docker compose -f compose.yaml -f compose.prod.yaml ps

curl http://localhost:3001/status

{
  "api": "ok",
  "postgres": {
    "connected": true,
    "serverTime": "2026-09-02T10:00:00.000Z"
  },
  "redis": {
    "connected": true,
    "lastStatusCheck": "2026-09-02T10:00:00.000Z"
  }
}

docker compose ps

docker compose exec api sh

getent hosts postgres
getent hosts redis

postgresql://app:app_password@localhost:5432/app
redis://localhost:6379

postgresql://app:app_password@postgres:5432/app
redis://redis:6379

docker volume ls

docker network ls

docker compose stop

docker compose start

docker compose down

docker compose down -v

docker compose build --no-cache

postgres
redis

depends_on:
  postgres:
    condition: service_healthy

volumes:
  - ./api:/app

volumes:
  - ./api:/app
  - api_node_modules:/app/node_modules

ports:
  - "5432:5432"

ports:
  - "6379:6379"

http://api:3001

http://localhost:3001

docker compose down -v