1
services:
2
  api:
3
    build:
4
      context: .
5
      dockerfile: ./Dockerfile
6
    ports:
7
      - "5400:5400"
8
    env_file:
9
      - ./.env.production
10
    depends_on:
11
      postgres:
12
        condition: service_healthy
13
      minio:
14
        condition: service_started
15

16
  minio:
17
    image: quay.io/minio/minio:latest
18
    command: server /data --console-address ":9001"
19
    ports:
20
      - "9000:9000"
21
      - "9001:9001"
22
    env_file:
23
      - ./.env.production
24
    volumes:
25
      - minio_data:/data
26
    healthcheck:
27
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/ready"]
28
      interval: 5s
29
      timeout: 3s
30
      retries: 10
31

32
  minio-init:
33
    image: minio/mc
34
    depends_on:
35
      minio:
36
        condition: service_healthy
37
    entrypoint: >
38
      /bin/sh -c "
39
      mc alias set local http://minio:9000 $MINIO_ROOT_USER $MINIO_ROOT_PASSWORD &&
40
      mc mb -p local/$S3_BUCKET || true &&
41
      mc mb -p local/posts || true &&
42
      mc anonymous set download local/$S3_BUCKET &&
43
      mc anonymous set download local/posts
44
      "
45
    env_file:
46
      - ./.env.production
47

48
volumes:
49
  minio_data:

1
mc anonymous set download local/$S3_BUCKET
2
mc anonymous set download local/posts

1
http://localhost:9000/<bucket>/<nome-do-arquivo>

1
http://localhost:9000/posts/foto.png

1
import { randomUUID } from 'node:crypto';
2
import {
3
  DeleteObjectCommand,
4
  PutObjectCommand,
5
  S3Client
6
} from '@aws-sdk/client-s3';
7
import { ConfigService } from '@nestjs/config';
8

9
import { Logger } from '@nestjs/common';
10
import { UploadDriver } from '~/app/upload/upload.interface';
11
import { AppConfig } from '~/config';
12
import { AppBucket } from '~/config/storage';
13

14
export class S3UploadProvider implements UploadDriver {
15
  private readonly s3: S3Client;
16
  private readonly bucket: string;
17
  private readonly publicUrl: string;
18
  private logger = new Logger(S3UploadProvider.name);
19

20
  constructor(config: ConfigService<AppConfig>, bucket: AppBucket | undefined) {
21
    this.bucket = bucket || config.get('S3_BUCKET')!;
22
    this.publicUrl = config.get('S3_PUBLIC_URL')!;
23

24
    this.s3 = new S3Client({
25
      region: config.get('S3_REGION'),
26
      endpoint: config.get('S3_ENDPOINT'),
27
      credentials: {
28
        accessKeyId: config.get('S3_ACCESS_KEY')!,
29
        secretAccessKey: config.get('S3_SECRET_KEY')!
30
      },
31
      forcePathStyle: true
32
    });
33
  }
34

35
  // Método que separa bucket do prefixo de pastas dentro do bucket, caso exista
36
  getKeyAndBucket() {
37
    this.logger.debug(
38
      `Getting key and bucket for bucket string: ${this.bucket}`
39
    );
40
    const [Bucket, ...prefix] = this.bucket.split('/');
41
    const folders = prefix.join('/');
42
    this.logger.debug(`Parsed Bucket: ${Bucket}, Folders: ${folders}`);
43

44
    return { Bucket, folders };
45
  }
46

47
  // Método para upload de arquivo
48
  async upload(file: Express.Multer.File) {
49
    this.logger.debug(
50
      `Uploading file: ${file.originalname} to bucket: ${this.bucket}`
51
    );
52
    // Gera um ID único concatenando um UUID com o nome original do arquivo
53
    const id = randomUUID().concat(file.originalname);
54
    this.logger.debug(`Generated unique ID for file: ${id}`);
55

56
    // Monta a chave (key) no bucket, considerando possíveis subpastas
57
    const [bucket, ...folders] = this.bucket.split('/');
58
    const key = folders.length ? `${folders.join('/')}/${id}` : id;
59
    this.logger.debug(`Final S3 Key for upload: ${key}`);
60

61
    // Envia o arquivo para o S3/MinIO
62
    await this.s3.send(
63
      new PutObjectCommand({
64
        Bucket: bucket,
65
        Key: key,
66
        Body: file.buffer,
67
        ContentType: file.mimetype,
68
        CacheControl: 'public, max-age=31536000, immutable' // cache longo para assets estáticos
69
      })
70
    );
71

72
    // Gera a URL pública do arquivo
73
    const url = new URL(`${bucket}/${key}`, this.publicUrl).toString();
74

75
    this.logger.debug(`File uploaded successfully. Accessible at: ${url}`);
76

77
    return {
78
      key,
79
      url
80
    };
81
  }
82

83
  // Método para deletar arquivo pelo key
84
  async delete(key: string): Promise<void> {
85
    this.logger.debug(
86
      `Deleting file with key: ${key} from bucket: ${this.bucket}`
87
    );
88

89
    await this.s3.send(
90
      new DeleteObjectCommand({
91
        Bucket: this.getKeyAndBucket().Bucket,
92
        Key: key
93
      })
94
    );
95

96
    this.logger.debug(`File with key: ${key} deleted successfully.`);
97
  }
98
}