gRPC, Nest.js kép méretező

POWERSHELL
Copy code
npm i -g @nestjs/cli

POWERSHELL
Copy code
nest new grpc-picture-resize

POWERSHELL
Copy code
nest g app resize

POWERSHELL
Copy code
npm install @nestjs/microservices 

POWERSHELL
Copy code
npm install @grpc/proto-loader @grpc/grpc-js ts-proto

POWERSHELL
Copy code
npm install sharp

JSON
Copy code
//nest-cli.json
{
  "$schema": "https://json.schemastore.org/nest-cli",
  "collection": "@nestjs/schematics",
  "sourceRoot": "apps/grpc-picture-resize/src",
  "compilerOptions": {
    "deleteOutDir": true,
    "webpack": true,
    "tsConfigPath": "apps/grpc-picture-resize/tsconfig.app.json"
  },
  "monorepo": true,
  "root": "apps/grpc-picture-resize",
  "projects": {
    "grpc-picture-resize": {
      "type": "application",
      "root": "apps/grpc-picture-resize",
      "entryFile": "src/main",
      "sourceRoot": "./",
      "compilerOptions": {
        "tsConfigPath": "apps/grpc-picture-resize/tsconfig.app.json",
        "assets": [
          "proto/*.proto"
        ],
        "watchAssets": true
      }
    },
    "resize": {
      "type": "application",
      "root": "apps/resize",
      "entryFile": "src/main",
      "sourceRoot": "./",
      "compilerOptions": {
        "tsConfigPath": "apps/resize/tsconfig.app.json",
        "assets": [
          "proto/*.proto"
        ],
        "watchAssets": true
      }
    }
  }
}

PLAIN TEXT
Copy code
//resize.prote
syntax = "proto3";

package resize;

service ImageResizer {
  rpc ResizeImage (ResizeRequest) returns (ResizeResponse) {}
}

message ResizeRequest {
  bytes image = 1;
  int32 width = 2;
  int32 height = 3;
}

message ResizeResponse {
  string fileName = 1;
  int32 resizedWidth = 2;
  int32 resizedHeight = 3;
}

POWERSHELL
Copy code
protoc --plugin=protoc-gen-ts_proto="C:\path\to\your\project\folder\node_modules\.bin\protoc-gen-ts_proto.cmd" --ts_proto_out=./ --ts_proto_opt=nestJs=true ./proto/min.proto

TYPESCRIPT
Copy code
//grpc-picture-resize/src/app.controller.ts
import { Body, Controller, Post } from '@nestjs/common';
import { AppService } from './app.service';
import fetch from 'node-fetch';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Post('/resize')
  async resizeImageByUrl(
    @Body() body: { imageUrl: string; width: number; height: number },
  ) {
    // Downloading the image from the provided URL
    const response = await fetch(body.imageUrl);
    if (!response.ok) {
      throw new Error('Failed to download the image');
    }
    const imageBuffer = await response.buffer();

    // Creating a resize request with the downloaded image
    const resizeRequest = {
      image: imageBuffer,
      width: body.width,
      height: body.height,
    };

    // Resizing the image using the gRPC service
    return this.appService.resizeImage(resizeRequest);
  }
}

TYPESCRIPT
Copy code
//grpc-picture-resize/src/app.module.ts
import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { join } from 'path';

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'resize',
        transport: Transport.GRPC,
        options: {
          package: 'resize',
          protoPath: join(__dirname, '../resize.proto'),
        },
      },
    ]),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

TYPESCRIPT
Copy code
//grpc-picture-resize/src/app.service.ts
import { Inject, Injectable, OnModuleInit } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';

import {
  ResizeRequest,
  IMAGE_RESIZER_SERVICE_NAME,
  ImageResizerClient,
} from 'proto/resize';

@Injectable()
export class AppService implements OnModuleInit {
  private imageResizerClient: ImageResizerClient;

  constructor(@Inject('resize') private clientGrpc: ClientGrpc) {}

  onModuleInit() {
    this.imageResizerClient = this.clientGrpc.getService<ImageResizerClient>(
      IMAGE_RESIZER_SERVICE_NAME,
    );
  }

  async resizeImage(resizeRequest: ResizeRequest) {
    const resizedImage = await this.imageResizerClient
      .resizeImage(resizeRequest)
      .toPromise();
    return resizedImage.fileName;
  }
}

TYPESCRIPT
Copy code
//grpc-picture-resize/src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

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

TYPESCRIPT
Copy code
//resize/src/resize.controller.ts
import { Controller } from '@nestjs/common';
import { GrpcMethod } from '@nestjs/microservices';
import { ResizeService } from './resize.service';
import { ResizeRequest, ResizeResponse } from 'proto/resize';

@Controller()
export class ResizeController {
  constructor(private readonly resizeService: ResizeService) {}

  @GrpcMethod('ImageResizer', 'ResizeImage')
  async resizeImage(resizeRequest: ResizeRequest): Promise<ResizeResponse> {
    return this.resizeService.resizeImage(resizeRequest);
  }
}

TYPESCRIPT
Copy code
//resize/src/resize.module.ts
import { Module } from '@nestjs/common';
import { ResizeService } from './resize.service';
import { ResizeController } from './resize.controller';

@Module({
  controllers: [ResizeController],
  providers: [ResizeService],
})
export class ResizeModule {}

TYPESCRIPT
Copy code
//resize/src/resize.service.ts
import { Injectable } from '@nestjs/common';
import * as sharp from 'sharp';
import { ResizeRequest, ResizeResponse } from 'proto/resize';
import * as fs from 'fs';
import * as path from 'path';

@Injectable()
export class ResizeService {
  private saveDirectory = path.join(__dirname, '../');

  async resizeImage(resizeRequest: ResizeRequest): Promise<ResizeResponse> {
    try {
      const fileName = `resized-${Date.now()}.jpg`;
      const outputPath = path.join(this.saveDirectory, fileName);

      const { data: resizedImage, info } = await sharp(
        Buffer.from(resizeRequest.image),
      )
        .resize(resizeRequest.width, resizeRequest.height)
        .toBuffer({ resolveWithObject: true });

      // Save to disk
      fs.writeFileSync(outputPath, resizedImage);

      return {
        fileName: fileName,
        resizedWidth: info.width,
        resizedHeight: info.height,
      };
    } catch (error) {
      console.error('Image resizing and saving failed: ', error.message);
      throw new Error(error.message);
    }
  }
}

TYPESCRIPT
Copy code
//resize/src/main.ts
import { NestFactory } from '@nestjs/core';
import { MicroserviceOptions, Transport } from '@nestjs/microservices';
import { ResizeModule } from './resize.module';
import { join } from 'path';

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
    ResizeModule,
    {
      transport: Transport.GRPC,
      options: {
        package: 'resize',
        protoPath: join(__dirname, '../resize.proto'),
      },
    },
  );

  await app.listen();
}

bootstrap();

POWERSHELL
Copy code
npm run start:dev resize

POWERSHELL
Copy code
npm run start:dev grpc-picture-resize

POWERSHELL
Copy code
curl -X POST